Termination of the given JBC could be proven:

(0) Obligation:

JBC Problem based on JBC Program:
Manifest-Version: 1.0 Created-By: 1.6.0_20 (Apple Inc.) Main-Class: Test9

public class Test9 {
    public static void main(String[] args) {
	long l = args.length;

	while (l > 0) {
	    for (int i = (int) l ; i < 100; i++)
		test(i);
	    l--;
	}
    }

    private static void test(int i) {
	int j, k, l, m;

	for (j = i; j > 0; j--);
	for (k = i; k > 0; k--);
	for (l = i; l > 0; l--);
	for (m = i; m > 0; m--);
	for (j = i; j > 0; j--);
	for (k = i; k > 0; k--);
	for (l = i; l > 0; l--);
	for (m = i; m > 0; m--);
	for (j = i; j > 0; j--);
	for (k = i; k > 0; k--);
	for (l = i; l > 0; l--);
	for (m = i; m > 0; m--);
    }
}

(1) JBCToGraph (SOUND transformation)

Constructed TerminationGraph.

(2) Obligation:

Termination Graph based on JBC Program:
Test9.main([Ljava/lang/String;)V: Graph of 58 nodes with 1 SCC.

Test9.test(I)V: Graph of 122 nodes with 12 SCCs.

(3) TerminationGraphToSCCProof (SOUND transformation)

Splitted TerminationGraph to 13 SCCss.

(4) Complex Obligation (AND)

(5) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.test(I)V
SCC calls the following helper methods:
Performed SCC analyses: UsedFieldsAnalysis

(6) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 6 rules for P and 0 rules for R.

P rules:
746_0_test_LE(EOS(STATIC_746), i208, i208) → 750_0_test_LE(EOS(STATIC_750), i208, i208)
750_0_test_LE(EOS(STATIC_750), i208, i208) → 753_0_test_Inc(EOS(STATIC_753), i208) | >(i208, 0)
753_0_test_Inc(EOS(STATIC_753), i208) → 759_0_test_JMP(EOS(STATIC_759), +(i208, -1)) | >(i208, 0)
759_0_test_JMP(EOS(STATIC_759), i211) → 770_0_test_Load(EOS(STATIC_770), i211)
770_0_test_Load(EOS(STATIC_770), i211) → 744_0_test_Load(EOS(STATIC_744), i211)
744_0_test_Load(EOS(STATIC_744), i203) → 746_0_test_LE(EOS(STATIC_746), i203, i203)
R rules:

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
746_0_test_LE(EOS(STATIC_746), x0, x0) → 746_0_test_LE(EOS(STATIC_746), +(x0, -1), +(x0, -1)) | >(x0, 0)
R rules:

Filtered ground terms:

746_0_test_LE(x1, x2, x3) → 746_0_test_LE(x2, x3)
EOS(x1) → EOS
Cond_746_0_test_LE(x1, x2, x3, x4) → Cond_746_0_test_LE(x1, x3, x4)

Filtered duplicate args:

746_0_test_LE(x1, x2) → 746_0_test_LE(x2)
Cond_746_0_test_LE(x1, x2, x3) → Cond_746_0_test_LE(x1, x3)

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
746_0_test_LE(x0) → 746_0_test_LE(+(x0, -1)) | >(x0, 0)
R rules:

Finished conversion. Obtained 2 rules for P and 0 rules for R. System has predefined symbols.

P rules:
746_0_TEST_LE(x0) → COND_746_0_TEST_LE(>(x0, 0), x0)
COND_746_0_TEST_LE(TRUE, x0) → 746_0_TEST_LE(+(x0, -1))
R rules:

(7) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 746_0_TEST_LE(x0[0]) → COND_746_0_TEST_LE(x0[0] > 0, x0[0])
(1): COND_746_0_TEST_LE(TRUE, x0[1]) → 746_0_TEST_LE(x0[1] + -1)

(0) -> (1), if (x0[0] > 0 ∧x0[0] →^* x0[1])

(1) -> (0), if (x0[1] + -1 →^* x0[0])

The set Q is empty.

(8) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 746_0_TEST_LE(x0) → COND_746_0_TEST_LE(>(x0, 0), x0) the following chains were created:

• We consider the chain 746_0_TEST_LE(x0[0]) → COND_746_0_TEST_LE(>(x0[0], 0), x0[0]), COND_746_0_TEST_LE(TRUE, x0[1]) → 746_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (1)    (>(x0[0], 0)=TRUE∧x0[0]=x0[1] ⇒ 746_0_TEST_LE(x0[0])≥NonInfC∧746_0_TEST_LE(x0[0])≥COND_746_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_746_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (>(x0[0], 0)=TRUE ⇒ 746_0_TEST_LE(x0[0])≥NonInfC∧746_0_TEST_LE(x0[0])≥COND_746_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_746_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_746_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_746_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_746_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (6)    (x0[0] ≥ 0 ⇒ (U^Increasing(COND_746_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  

For Pair COND_746_0_TEST_LE(TRUE, x0) → 746_0_TEST_LE(+(x0, -1)) the following chains were created:

• We consider the chain COND_746_0_TEST_LE(TRUE, x0[1]) → 746_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (7)    (COND_746_0_TEST_LE(TRUE, x0[1])≥NonInfC∧COND_746_0_TEST_LE(TRUE, x0[1])≥746_0_TEST_LE(+(x0[1], -1))∧(U^Increasing(746_0_TEST_LE(+(x0[1], -1))), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    ((U^Increasing(746_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    ((U^Increasing(746_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    ((U^Increasing(746_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (11)    ((U^Increasing(746_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 746_0_TEST_LE(x0) → COND_746_0_TEST_LE(>(x0, 0), x0)
  
  • (x0[0] ≥ 0 ⇒ (U^Increasing(COND_746_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)
    
  
  
• COND_746_0_TEST_LE(TRUE, x0) → 746_0_TEST_LE(+(x0, -1))
  
  • ((U^Increasing(746_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(746_0_TEST_LE(x₁)) = [2]x₁   
POL(COND_746_0_TEST_LE(x₁, x₂)) = [2]x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   

The following pairs are in P_>:

COND_746_0_TEST_LE(TRUE, x0[1]) → 746_0_TEST_LE(+(x0[1], -1))

The following pairs are in P_bound:

746_0_TEST_LE(x0[0]) → COND_746_0_TEST_LE(>(x0[0], 0), x0[0])

The following pairs are in P_≥:

746_0_TEST_LE(x0[0]) → COND_746_0_TEST_LE(>(x0[0], 0), x0[0])

There are no usable rules.

(9) Complex Obligation (AND)

(10) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 746_0_TEST_LE(x0[0]) → COND_746_0_TEST_LE(x0[0] > 0, x0[0])


The set Q is empty.

(11) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(12) TRUE

(13) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_746_0_TEST_LE(TRUE, x0[1]) → 746_0_TEST_LE(x0[1] + -1)


The set Q is empty.

(14) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(15) TRUE

(16) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.test(I)V
SCC calls the following helper methods:
Performed SCC analyses: UsedFieldsAnalysis

(17) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 6 rules for P and 0 rules for R.

P rules:
715_0_test_LE(EOS(STATIC_715), i197, i197) → 718_0_test_LE(EOS(STATIC_718), i197, i197)
718_0_test_LE(EOS(STATIC_718), i197, i197) → 722_0_test_Inc(EOS(STATIC_722), i197) | >(i197, 0)
722_0_test_Inc(EOS(STATIC_722), i197) → 726_0_test_JMP(EOS(STATIC_726), +(i197, -1)) | >(i197, 0)
726_0_test_JMP(EOS(STATIC_726), i199) → 731_0_test_Load(EOS(STATIC_731), i199)
731_0_test_Load(EOS(STATIC_731), i199) → 713_0_test_Load(EOS(STATIC_713), i199)
713_0_test_Load(EOS(STATIC_713), i194) → 715_0_test_LE(EOS(STATIC_715), i194, i194)
R rules:

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
715_0_test_LE(EOS(STATIC_715), x0, x0) → 715_0_test_LE(EOS(STATIC_715), +(x0, -1), +(x0, -1)) | >(x0, 0)
R rules:

Filtered ground terms:

715_0_test_LE(x1, x2, x3) → 715_0_test_LE(x2, x3)
EOS(x1) → EOS
Cond_715_0_test_LE(x1, x2, x3, x4) → Cond_715_0_test_LE(x1, x3, x4)

Filtered duplicate args:

715_0_test_LE(x1, x2) → 715_0_test_LE(x2)
Cond_715_0_test_LE(x1, x2, x3) → Cond_715_0_test_LE(x1, x3)

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
715_0_test_LE(x0) → 715_0_test_LE(+(x0, -1)) | >(x0, 0)
R rules:

Finished conversion. Obtained 2 rules for P and 0 rules for R. System has predefined symbols.

P rules:
715_0_TEST_LE(x0) → COND_715_0_TEST_LE(>(x0, 0), x0)
COND_715_0_TEST_LE(TRUE, x0) → 715_0_TEST_LE(+(x0, -1))
R rules:

(18) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 715_0_TEST_LE(x0[0]) → COND_715_0_TEST_LE(x0[0] > 0, x0[0])
(1): COND_715_0_TEST_LE(TRUE, x0[1]) → 715_0_TEST_LE(x0[1] + -1)

(0) -> (1), if (x0[0] > 0 ∧x0[0] →^* x0[1])

(1) -> (0), if (x0[1] + -1 →^* x0[0])

The set Q is empty.

(19) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 715_0_TEST_LE(x0) → COND_715_0_TEST_LE(>(x0, 0), x0) the following chains were created:

• We consider the chain 715_0_TEST_LE(x0[0]) → COND_715_0_TEST_LE(>(x0[0], 0), x0[0]), COND_715_0_TEST_LE(TRUE, x0[1]) → 715_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (1)    (>(x0[0], 0)=TRUE∧x0[0]=x0[1] ⇒ 715_0_TEST_LE(x0[0])≥NonInfC∧715_0_TEST_LE(x0[0])≥COND_715_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_715_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (>(x0[0], 0)=TRUE ⇒ 715_0_TEST_LE(x0[0])≥NonInfC∧715_0_TEST_LE(x0[0])≥COND_715_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_715_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_715_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_715_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_715_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (6)    (x0[0] ≥ 0 ⇒ (U^Increasing(COND_715_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  

For Pair COND_715_0_TEST_LE(TRUE, x0) → 715_0_TEST_LE(+(x0, -1)) the following chains were created:

• We consider the chain COND_715_0_TEST_LE(TRUE, x0[1]) → 715_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (7)    (COND_715_0_TEST_LE(TRUE, x0[1])≥NonInfC∧COND_715_0_TEST_LE(TRUE, x0[1])≥715_0_TEST_LE(+(x0[1], -1))∧(U^Increasing(715_0_TEST_LE(+(x0[1], -1))), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    ((U^Increasing(715_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    ((U^Increasing(715_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    ((U^Increasing(715_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (11)    ((U^Increasing(715_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 715_0_TEST_LE(x0) → COND_715_0_TEST_LE(>(x0, 0), x0)
  
  • (x0[0] ≥ 0 ⇒ (U^Increasing(COND_715_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)
    
  
  
• COND_715_0_TEST_LE(TRUE, x0) → 715_0_TEST_LE(+(x0, -1))
  
  • ((U^Increasing(715_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(715_0_TEST_LE(x₁)) = [2]x₁   
POL(COND_715_0_TEST_LE(x₁, x₂)) = [2]x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   

The following pairs are in P_>:

COND_715_0_TEST_LE(TRUE, x0[1]) → 715_0_TEST_LE(+(x0[1], -1))

The following pairs are in P_bound:

715_0_TEST_LE(x0[0]) → COND_715_0_TEST_LE(>(x0[0], 0), x0[0])

The following pairs are in P_≥:

715_0_TEST_LE(x0[0]) → COND_715_0_TEST_LE(>(x0[0], 0), x0[0])

There are no usable rules.

(20) Complex Obligation (AND)

(21) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 715_0_TEST_LE(x0[0]) → COND_715_0_TEST_LE(x0[0] > 0, x0[0])


The set Q is empty.

(22) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(23) TRUE

(24) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_715_0_TEST_LE(TRUE, x0[1]) → 715_0_TEST_LE(x0[1] + -1)


The set Q is empty.

(25) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(26) TRUE

(27) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.test(I)V
SCC calls the following helper methods:
Performed SCC analyses: UsedFieldsAnalysis

(28) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 6 rules for P and 0 rules for R.

P rules:
680_0_test_LE(EOS(STATIC_680), i189, i189) → 683_0_test_LE(EOS(STATIC_683), i189, i189)
683_0_test_LE(EOS(STATIC_683), i189, i189) → 688_0_test_Inc(EOS(STATIC_688), i189) | >(i189, 0)
688_0_test_Inc(EOS(STATIC_688), i189) → 692_0_test_JMP(EOS(STATIC_692), +(i189, -1)) | >(i189, 0)
692_0_test_JMP(EOS(STATIC_692), i191) → 699_0_test_Load(EOS(STATIC_699), i191)
699_0_test_Load(EOS(STATIC_699), i191) → 676_0_test_Load(EOS(STATIC_676), i191)
676_0_test_Load(EOS(STATIC_676), i184) → 680_0_test_LE(EOS(STATIC_680), i184, i184)
R rules:

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
680_0_test_LE(EOS(STATIC_680), x0, x0) → 680_0_test_LE(EOS(STATIC_680), +(x0, -1), +(x0, -1)) | >(x0, 0)
R rules:

Filtered ground terms:

680_0_test_LE(x1, x2, x3) → 680_0_test_LE(x2, x3)
EOS(x1) → EOS
Cond_680_0_test_LE(x1, x2, x3, x4) → Cond_680_0_test_LE(x1, x3, x4)

Filtered duplicate args:

680_0_test_LE(x1, x2) → 680_0_test_LE(x2)
Cond_680_0_test_LE(x1, x2, x3) → Cond_680_0_test_LE(x1, x3)

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
680_0_test_LE(x0) → 680_0_test_LE(+(x0, -1)) | >(x0, 0)
R rules:

Finished conversion. Obtained 2 rules for P and 0 rules for R. System has predefined symbols.

P rules:
680_0_TEST_LE(x0) → COND_680_0_TEST_LE(>(x0, 0), x0)
COND_680_0_TEST_LE(TRUE, x0) → 680_0_TEST_LE(+(x0, -1))
R rules:

(29) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 680_0_TEST_LE(x0[0]) → COND_680_0_TEST_LE(x0[0] > 0, x0[0])
(1): COND_680_0_TEST_LE(TRUE, x0[1]) → 680_0_TEST_LE(x0[1] + -1)

(0) -> (1), if (x0[0] > 0 ∧x0[0] →^* x0[1])

(1) -> (0), if (x0[1] + -1 →^* x0[0])

The set Q is empty.

(30) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 680_0_TEST_LE(x0) → COND_680_0_TEST_LE(>(x0, 0), x0) the following chains were created:

• We consider the chain 680_0_TEST_LE(x0[0]) → COND_680_0_TEST_LE(>(x0[0], 0), x0[0]), COND_680_0_TEST_LE(TRUE, x0[1]) → 680_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (1)    (>(x0[0], 0)=TRUE∧x0[0]=x0[1] ⇒ 680_0_TEST_LE(x0[0])≥NonInfC∧680_0_TEST_LE(x0[0])≥COND_680_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_680_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (>(x0[0], 0)=TRUE ⇒ 680_0_TEST_LE(x0[0])≥NonInfC∧680_0_TEST_LE(x0[0])≥COND_680_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_680_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_680_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_680_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_680_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (6)    (x0[0] ≥ 0 ⇒ (U^Increasing(COND_680_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  

For Pair COND_680_0_TEST_LE(TRUE, x0) → 680_0_TEST_LE(+(x0, -1)) the following chains were created:

• We consider the chain COND_680_0_TEST_LE(TRUE, x0[1]) → 680_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (7)    (COND_680_0_TEST_LE(TRUE, x0[1])≥NonInfC∧COND_680_0_TEST_LE(TRUE, x0[1])≥680_0_TEST_LE(+(x0[1], -1))∧(U^Increasing(680_0_TEST_LE(+(x0[1], -1))), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    ((U^Increasing(680_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    ((U^Increasing(680_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    ((U^Increasing(680_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (11)    ((U^Increasing(680_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 680_0_TEST_LE(x0) → COND_680_0_TEST_LE(>(x0, 0), x0)
  
  • (x0[0] ≥ 0 ⇒ (U^Increasing(COND_680_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)
    
  
  
• COND_680_0_TEST_LE(TRUE, x0) → 680_0_TEST_LE(+(x0, -1))
  
  • ((U^Increasing(680_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(680_0_TEST_LE(x₁)) = [2]x₁   
POL(COND_680_0_TEST_LE(x₁, x₂)) = [2]x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   

The following pairs are in P_>:

COND_680_0_TEST_LE(TRUE, x0[1]) → 680_0_TEST_LE(+(x0[1], -1))

The following pairs are in P_bound:

680_0_TEST_LE(x0[0]) → COND_680_0_TEST_LE(>(x0[0], 0), x0[0])

The following pairs are in P_≥:

680_0_TEST_LE(x0[0]) → COND_680_0_TEST_LE(>(x0[0], 0), x0[0])

There are no usable rules.

(31) Complex Obligation (AND)

(32) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 680_0_TEST_LE(x0[0]) → COND_680_0_TEST_LE(x0[0] > 0, x0[0])


The set Q is empty.

(33) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(34) TRUE

(35) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_680_0_TEST_LE(TRUE, x0[1]) → 680_0_TEST_LE(x0[1] + -1)


The set Q is empty.

(36) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(37) TRUE

(38) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.test(I)V
SCC calls the following helper methods:
Performed SCC analyses: UsedFieldsAnalysis

(39) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 6 rules for P and 0 rules for R.

P rules:
641_0_test_LE(EOS(STATIC_641), i173, i173) → 645_0_test_LE(EOS(STATIC_645), i173, i173)
645_0_test_LE(EOS(STATIC_645), i173, i173) → 649_0_test_Inc(EOS(STATIC_649), i173) | >(i173, 0)
649_0_test_Inc(EOS(STATIC_649), i173) → 654_0_test_JMP(EOS(STATIC_654), +(i173, -1)) | >(i173, 0)
654_0_test_JMP(EOS(STATIC_654), i177) → 660_0_test_Load(EOS(STATIC_660), i177)
660_0_test_Load(EOS(STATIC_660), i177) → 637_0_test_Load(EOS(STATIC_637), i177)
637_0_test_Load(EOS(STATIC_637), i169) → 641_0_test_LE(EOS(STATIC_641), i169, i169)
R rules:

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
641_0_test_LE(EOS(STATIC_641), x0, x0) → 641_0_test_LE(EOS(STATIC_641), +(x0, -1), +(x0, -1)) | >(x0, 0)
R rules:

Filtered ground terms:

641_0_test_LE(x1, x2, x3) → 641_0_test_LE(x2, x3)
EOS(x1) → EOS
Cond_641_0_test_LE(x1, x2, x3, x4) → Cond_641_0_test_LE(x1, x3, x4)

Filtered duplicate args:

641_0_test_LE(x1, x2) → 641_0_test_LE(x2)
Cond_641_0_test_LE(x1, x2, x3) → Cond_641_0_test_LE(x1, x3)

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
641_0_test_LE(x0) → 641_0_test_LE(+(x0, -1)) | >(x0, 0)
R rules:

Finished conversion. Obtained 2 rules for P and 0 rules for R. System has predefined symbols.

P rules:
641_0_TEST_LE(x0) → COND_641_0_TEST_LE(>(x0, 0), x0)
COND_641_0_TEST_LE(TRUE, x0) → 641_0_TEST_LE(+(x0, -1))
R rules:

(40) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 641_0_TEST_LE(x0[0]) → COND_641_0_TEST_LE(x0[0] > 0, x0[0])
(1): COND_641_0_TEST_LE(TRUE, x0[1]) → 641_0_TEST_LE(x0[1] + -1)

(0) -> (1), if (x0[0] > 0 ∧x0[0] →^* x0[1])

(1) -> (0), if (x0[1] + -1 →^* x0[0])

The set Q is empty.

(41) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 641_0_TEST_LE(x0) → COND_641_0_TEST_LE(>(x0, 0), x0) the following chains were created:

• We consider the chain 641_0_TEST_LE(x0[0]) → COND_641_0_TEST_LE(>(x0[0], 0), x0[0]), COND_641_0_TEST_LE(TRUE, x0[1]) → 641_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (1)    (>(x0[0], 0)=TRUE∧x0[0]=x0[1] ⇒ 641_0_TEST_LE(x0[0])≥NonInfC∧641_0_TEST_LE(x0[0])≥COND_641_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_641_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (>(x0[0], 0)=TRUE ⇒ 641_0_TEST_LE(x0[0])≥NonInfC∧641_0_TEST_LE(x0[0])≥COND_641_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_641_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_641_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_641_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_641_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (6)    (x0[0] ≥ 0 ⇒ (U^Increasing(COND_641_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  

For Pair COND_641_0_TEST_LE(TRUE, x0) → 641_0_TEST_LE(+(x0, -1)) the following chains were created:

• We consider the chain COND_641_0_TEST_LE(TRUE, x0[1]) → 641_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (7)    (COND_641_0_TEST_LE(TRUE, x0[1])≥NonInfC∧COND_641_0_TEST_LE(TRUE, x0[1])≥641_0_TEST_LE(+(x0[1], -1))∧(U^Increasing(641_0_TEST_LE(+(x0[1], -1))), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    ((U^Increasing(641_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    ((U^Increasing(641_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    ((U^Increasing(641_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (11)    ((U^Increasing(641_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 641_0_TEST_LE(x0) → COND_641_0_TEST_LE(>(x0, 0), x0)
  
  • (x0[0] ≥ 0 ⇒ (U^Increasing(COND_641_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)
    
  
  
• COND_641_0_TEST_LE(TRUE, x0) → 641_0_TEST_LE(+(x0, -1))
  
  • ((U^Increasing(641_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(641_0_TEST_LE(x₁)) = [2]x₁   
POL(COND_641_0_TEST_LE(x₁, x₂)) = [2]x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   

The following pairs are in P_>:

COND_641_0_TEST_LE(TRUE, x0[1]) → 641_0_TEST_LE(+(x0[1], -1))

The following pairs are in P_bound:

641_0_TEST_LE(x0[0]) → COND_641_0_TEST_LE(>(x0[0], 0), x0[0])

The following pairs are in P_≥:

641_0_TEST_LE(x0[0]) → COND_641_0_TEST_LE(>(x0[0], 0), x0[0])

There are no usable rules.

(42) Complex Obligation (AND)

(43) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 641_0_TEST_LE(x0[0]) → COND_641_0_TEST_LE(x0[0] > 0, x0[0])


The set Q is empty.

(44) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(45) TRUE

(46) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_641_0_TEST_LE(TRUE, x0[1]) → 641_0_TEST_LE(x0[1] + -1)


The set Q is empty.

(47) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(48) TRUE

(49) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.test(I)V
SCC calls the following helper methods:
Performed SCC analyses: UsedFieldsAnalysis

(50) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 6 rules for P and 0 rules for R.

P rules:
602_0_test_LE(EOS(STATIC_602), i161, i161) → 606_0_test_LE(EOS(STATIC_606), i161, i161)
606_0_test_LE(EOS(STATIC_606), i161, i161) → 610_0_test_Inc(EOS(STATIC_610), i161) | >(i161, 0)
610_0_test_Inc(EOS(STATIC_610), i161) → 614_0_test_JMP(EOS(STATIC_614), +(i161, -1)) | >(i161, 0)
614_0_test_JMP(EOS(STATIC_614), i163) → 621_0_test_Load(EOS(STATIC_621), i163)
621_0_test_Load(EOS(STATIC_621), i163) → 598_0_test_Load(EOS(STATIC_598), i163)
598_0_test_Load(EOS(STATIC_598), i157) → 602_0_test_LE(EOS(STATIC_602), i157, i157)
R rules:

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
602_0_test_LE(EOS(STATIC_602), x0, x0) → 602_0_test_LE(EOS(STATIC_602), +(x0, -1), +(x0, -1)) | >(x0, 0)
R rules:

Filtered ground terms:

602_0_test_LE(x1, x2, x3) → 602_0_test_LE(x2, x3)
EOS(x1) → EOS
Cond_602_0_test_LE(x1, x2, x3, x4) → Cond_602_0_test_LE(x1, x3, x4)

Filtered duplicate args:

602_0_test_LE(x1, x2) → 602_0_test_LE(x2)
Cond_602_0_test_LE(x1, x2, x3) → Cond_602_0_test_LE(x1, x3)

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
602_0_test_LE(x0) → 602_0_test_LE(+(x0, -1)) | >(x0, 0)
R rules:

Finished conversion. Obtained 2 rules for P and 0 rules for R. System has predefined symbols.

P rules:
602_0_TEST_LE(x0) → COND_602_0_TEST_LE(>(x0, 0), x0)
COND_602_0_TEST_LE(TRUE, x0) → 602_0_TEST_LE(+(x0, -1))
R rules:

(51) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 602_0_TEST_LE(x0[0]) → COND_602_0_TEST_LE(x0[0] > 0, x0[0])
(1): COND_602_0_TEST_LE(TRUE, x0[1]) → 602_0_TEST_LE(x0[1] + -1)

(0) -> (1), if (x0[0] > 0 ∧x0[0] →^* x0[1])

(1) -> (0), if (x0[1] + -1 →^* x0[0])

The set Q is empty.

(52) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 602_0_TEST_LE(x0) → COND_602_0_TEST_LE(>(x0, 0), x0) the following chains were created:

• We consider the chain 602_0_TEST_LE(x0[0]) → COND_602_0_TEST_LE(>(x0[0], 0), x0[0]), COND_602_0_TEST_LE(TRUE, x0[1]) → 602_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (1)    (>(x0[0], 0)=TRUE∧x0[0]=x0[1] ⇒ 602_0_TEST_LE(x0[0])≥NonInfC∧602_0_TEST_LE(x0[0])≥COND_602_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_602_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (>(x0[0], 0)=TRUE ⇒ 602_0_TEST_LE(x0[0])≥NonInfC∧602_0_TEST_LE(x0[0])≥COND_602_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_602_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_602_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_602_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_602_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (6)    (x0[0] ≥ 0 ⇒ (U^Increasing(COND_602_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  

For Pair COND_602_0_TEST_LE(TRUE, x0) → 602_0_TEST_LE(+(x0, -1)) the following chains were created:

• We consider the chain COND_602_0_TEST_LE(TRUE, x0[1]) → 602_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (7)    (COND_602_0_TEST_LE(TRUE, x0[1])≥NonInfC∧COND_602_0_TEST_LE(TRUE, x0[1])≥602_0_TEST_LE(+(x0[1], -1))∧(U^Increasing(602_0_TEST_LE(+(x0[1], -1))), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    ((U^Increasing(602_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    ((U^Increasing(602_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    ((U^Increasing(602_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (11)    ((U^Increasing(602_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 602_0_TEST_LE(x0) → COND_602_0_TEST_LE(>(x0, 0), x0)
  
  • (x0[0] ≥ 0 ⇒ (U^Increasing(COND_602_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)
    
  
  
• COND_602_0_TEST_LE(TRUE, x0) → 602_0_TEST_LE(+(x0, -1))
  
  • ((U^Increasing(602_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(602_0_TEST_LE(x₁)) = [2]x₁   
POL(COND_602_0_TEST_LE(x₁, x₂)) = [2]x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   

The following pairs are in P_>:

COND_602_0_TEST_LE(TRUE, x0[1]) → 602_0_TEST_LE(+(x0[1], -1))

The following pairs are in P_bound:

602_0_TEST_LE(x0[0]) → COND_602_0_TEST_LE(>(x0[0], 0), x0[0])

The following pairs are in P_≥:

602_0_TEST_LE(x0[0]) → COND_602_0_TEST_LE(>(x0[0], 0), x0[0])

There are no usable rules.

(53) Complex Obligation (AND)

(54) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 602_0_TEST_LE(x0[0]) → COND_602_0_TEST_LE(x0[0] > 0, x0[0])


The set Q is empty.

(55) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(56) TRUE

(57) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_602_0_TEST_LE(TRUE, x0[1]) → 602_0_TEST_LE(x0[1] + -1)


The set Q is empty.

(58) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(59) TRUE

(60) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.test(I)V
SCC calls the following helper methods:
Performed SCC analyses: UsedFieldsAnalysis

(61) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 6 rules for P and 0 rules for R.

P rules:
564_0_test_LE(EOS(STATIC_564), i148, i148) → 568_0_test_LE(EOS(STATIC_568), i148, i148)
568_0_test_LE(EOS(STATIC_568), i148, i148) → 572_0_test_Inc(EOS(STATIC_572), i148) | >(i148, 0)
572_0_test_Inc(EOS(STATIC_572), i148) → 577_0_test_JMP(EOS(STATIC_577), +(i148, -1)) | >(i148, 0)
577_0_test_JMP(EOS(STATIC_577), i151) → 583_0_test_Load(EOS(STATIC_583), i151)
583_0_test_Load(EOS(STATIC_583), i151) → 561_0_test_Load(EOS(STATIC_561), i151)
561_0_test_Load(EOS(STATIC_561), i143) → 564_0_test_LE(EOS(STATIC_564), i143, i143)
R rules:

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
564_0_test_LE(EOS(STATIC_564), x0, x0) → 564_0_test_LE(EOS(STATIC_564), +(x0, -1), +(x0, -1)) | >(x0, 0)
R rules:

Filtered ground terms:

564_0_test_LE(x1, x2, x3) → 564_0_test_LE(x2, x3)
EOS(x1) → EOS
Cond_564_0_test_LE(x1, x2, x3, x4) → Cond_564_0_test_LE(x1, x3, x4)

Filtered duplicate args:

564_0_test_LE(x1, x2) → 564_0_test_LE(x2)
Cond_564_0_test_LE(x1, x2, x3) → Cond_564_0_test_LE(x1, x3)

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
564_0_test_LE(x0) → 564_0_test_LE(+(x0, -1)) | >(x0, 0)
R rules:

Finished conversion. Obtained 2 rules for P and 0 rules for R. System has predefined symbols.

P rules:
564_0_TEST_LE(x0) → COND_564_0_TEST_LE(>(x0, 0), x0)
COND_564_0_TEST_LE(TRUE, x0) → 564_0_TEST_LE(+(x0, -1))
R rules:

(62) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 564_0_TEST_LE(x0[0]) → COND_564_0_TEST_LE(x0[0] > 0, x0[0])
(1): COND_564_0_TEST_LE(TRUE, x0[1]) → 564_0_TEST_LE(x0[1] + -1)

(0) -> (1), if (x0[0] > 0 ∧x0[0] →^* x0[1])

(1) -> (0), if (x0[1] + -1 →^* x0[0])

The set Q is empty.

(63) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 564_0_TEST_LE(x0) → COND_564_0_TEST_LE(>(x0, 0), x0) the following chains were created:

• We consider the chain 564_0_TEST_LE(x0[0]) → COND_564_0_TEST_LE(>(x0[0], 0), x0[0]), COND_564_0_TEST_LE(TRUE, x0[1]) → 564_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (1)    (>(x0[0], 0)=TRUE∧x0[0]=x0[1] ⇒ 564_0_TEST_LE(x0[0])≥NonInfC∧564_0_TEST_LE(x0[0])≥COND_564_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_564_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (>(x0[0], 0)=TRUE ⇒ 564_0_TEST_LE(x0[0])≥NonInfC∧564_0_TEST_LE(x0[0])≥COND_564_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_564_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_564_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_564_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_564_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (6)    (x0[0] ≥ 0 ⇒ (U^Increasing(COND_564_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  

For Pair COND_564_0_TEST_LE(TRUE, x0) → 564_0_TEST_LE(+(x0, -1)) the following chains were created:

• We consider the chain COND_564_0_TEST_LE(TRUE, x0[1]) → 564_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (7)    (COND_564_0_TEST_LE(TRUE, x0[1])≥NonInfC∧COND_564_0_TEST_LE(TRUE, x0[1])≥564_0_TEST_LE(+(x0[1], -1))∧(U^Increasing(564_0_TEST_LE(+(x0[1], -1))), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    ((U^Increasing(564_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    ((U^Increasing(564_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    ((U^Increasing(564_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (11)    ((U^Increasing(564_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 564_0_TEST_LE(x0) → COND_564_0_TEST_LE(>(x0, 0), x0)
  
  • (x0[0] ≥ 0 ⇒ (U^Increasing(COND_564_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)
    
  
  
• COND_564_0_TEST_LE(TRUE, x0) → 564_0_TEST_LE(+(x0, -1))
  
  • ((U^Increasing(564_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(564_0_TEST_LE(x₁)) = [2]x₁   
POL(COND_564_0_TEST_LE(x₁, x₂)) = [2]x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   

The following pairs are in P_>:

COND_564_0_TEST_LE(TRUE, x0[1]) → 564_0_TEST_LE(+(x0[1], -1))

The following pairs are in P_bound:

564_0_TEST_LE(x0[0]) → COND_564_0_TEST_LE(>(x0[0], 0), x0[0])

The following pairs are in P_≥:

564_0_TEST_LE(x0[0]) → COND_564_0_TEST_LE(>(x0[0], 0), x0[0])

There are no usable rules.

(64) Complex Obligation (AND)

(65) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 564_0_TEST_LE(x0[0]) → COND_564_0_TEST_LE(x0[0] > 0, x0[0])


The set Q is empty.

(66) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(67) TRUE

(68) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_564_0_TEST_LE(TRUE, x0[1]) → 564_0_TEST_LE(x0[1] + -1)


The set Q is empty.

(69) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(70) TRUE

(71) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.test(I)V
SCC calls the following helper methods:
Performed SCC analyses: UsedFieldsAnalysis

(72) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 6 rules for P and 0 rules for R.

P rules:
528_0_test_LE(EOS(STATIC_528), i136, i136) → 531_0_test_LE(EOS(STATIC_531), i136, i136)
531_0_test_LE(EOS(STATIC_531), i136, i136) → 535_0_test_Inc(EOS(STATIC_535), i136) | >(i136, 0)
535_0_test_Inc(EOS(STATIC_535), i136) → 539_0_test_JMP(EOS(STATIC_539), +(i136, -1)) | >(i136, 0)
539_0_test_JMP(EOS(STATIC_539), i138) → 545_0_test_Load(EOS(STATIC_545), i138)
545_0_test_Load(EOS(STATIC_545), i138) → 525_0_test_Load(EOS(STATIC_525), i138)
525_0_test_Load(EOS(STATIC_525), i131) → 528_0_test_LE(EOS(STATIC_528), i131, i131)
R rules:

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
528_0_test_LE(EOS(STATIC_528), x0, x0) → 528_0_test_LE(EOS(STATIC_528), +(x0, -1), +(x0, -1)) | >(x0, 0)
R rules:

Filtered ground terms:

528_0_test_LE(x1, x2, x3) → 528_0_test_LE(x2, x3)
EOS(x1) → EOS
Cond_528_0_test_LE(x1, x2, x3, x4) → Cond_528_0_test_LE(x1, x3, x4)

Filtered duplicate args:

528_0_test_LE(x1, x2) → 528_0_test_LE(x2)
Cond_528_0_test_LE(x1, x2, x3) → Cond_528_0_test_LE(x1, x3)

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
528_0_test_LE(x0) → 528_0_test_LE(+(x0, -1)) | >(x0, 0)
R rules:

Finished conversion. Obtained 2 rules for P and 0 rules for R. System has predefined symbols.

P rules:
528_0_TEST_LE(x0) → COND_528_0_TEST_LE(>(x0, 0), x0)
COND_528_0_TEST_LE(TRUE, x0) → 528_0_TEST_LE(+(x0, -1))
R rules:

(73) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 528_0_TEST_LE(x0[0]) → COND_528_0_TEST_LE(x0[0] > 0, x0[0])
(1): COND_528_0_TEST_LE(TRUE, x0[1]) → 528_0_TEST_LE(x0[1] + -1)

(0) -> (1), if (x0[0] > 0 ∧x0[0] →^* x0[1])

(1) -> (0), if (x0[1] + -1 →^* x0[0])

The set Q is empty.

(74) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 528_0_TEST_LE(x0) → COND_528_0_TEST_LE(>(x0, 0), x0) the following chains were created:

• We consider the chain 528_0_TEST_LE(x0[0]) → COND_528_0_TEST_LE(>(x0[0], 0), x0[0]), COND_528_0_TEST_LE(TRUE, x0[1]) → 528_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (1)    (>(x0[0], 0)=TRUE∧x0[0]=x0[1] ⇒ 528_0_TEST_LE(x0[0])≥NonInfC∧528_0_TEST_LE(x0[0])≥COND_528_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_528_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (>(x0[0], 0)=TRUE ⇒ 528_0_TEST_LE(x0[0])≥NonInfC∧528_0_TEST_LE(x0[0])≥COND_528_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_528_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_528_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_528_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_528_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (6)    (x0[0] ≥ 0 ⇒ (U^Increasing(COND_528_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  

For Pair COND_528_0_TEST_LE(TRUE, x0) → 528_0_TEST_LE(+(x0, -1)) the following chains were created:

• We consider the chain COND_528_0_TEST_LE(TRUE, x0[1]) → 528_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (7)    (COND_528_0_TEST_LE(TRUE, x0[1])≥NonInfC∧COND_528_0_TEST_LE(TRUE, x0[1])≥528_0_TEST_LE(+(x0[1], -1))∧(U^Increasing(528_0_TEST_LE(+(x0[1], -1))), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    ((U^Increasing(528_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    ((U^Increasing(528_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    ((U^Increasing(528_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (11)    ((U^Increasing(528_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 528_0_TEST_LE(x0) → COND_528_0_TEST_LE(>(x0, 0), x0)
  
  • (x0[0] ≥ 0 ⇒ (U^Increasing(COND_528_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)
    
  
  
• COND_528_0_TEST_LE(TRUE, x0) → 528_0_TEST_LE(+(x0, -1))
  
  • ((U^Increasing(528_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(528_0_TEST_LE(x₁)) = [2]x₁   
POL(COND_528_0_TEST_LE(x₁, x₂)) = [2]x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   

The following pairs are in P_>:

COND_528_0_TEST_LE(TRUE, x0[1]) → 528_0_TEST_LE(+(x0[1], -1))

The following pairs are in P_bound:

528_0_TEST_LE(x0[0]) → COND_528_0_TEST_LE(>(x0[0], 0), x0[0])

The following pairs are in P_≥:

528_0_TEST_LE(x0[0]) → COND_528_0_TEST_LE(>(x0[0], 0), x0[0])

There are no usable rules.

(75) Complex Obligation (AND)

(76) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 528_0_TEST_LE(x0[0]) → COND_528_0_TEST_LE(x0[0] > 0, x0[0])


The set Q is empty.

(77) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(78) TRUE

(79) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_528_0_TEST_LE(TRUE, x0[1]) → 528_0_TEST_LE(x0[1] + -1)


The set Q is empty.

(80) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(81) TRUE

(82) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.test(I)V
SCC calls the following helper methods:
Performed SCC analyses: UsedFieldsAnalysis

(83) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 6 rules for P and 0 rules for R.

P rules:
496_0_test_LE(EOS(STATIC_496), i125, i125) → 500_0_test_LE(EOS(STATIC_500), i125, i125)
500_0_test_LE(EOS(STATIC_500), i125, i125) → 504_0_test_Inc(EOS(STATIC_504), i125) | >(i125, 0)
504_0_test_Inc(EOS(STATIC_504), i125) → 509_0_test_JMP(EOS(STATIC_509), +(i125, -1)) | >(i125, 0)
509_0_test_JMP(EOS(STATIC_509), i127) → 514_0_test_Load(EOS(STATIC_514), i127)
514_0_test_Load(EOS(STATIC_514), i127) → 493_0_test_Load(EOS(STATIC_493), i127)
493_0_test_Load(EOS(STATIC_493), i121) → 496_0_test_LE(EOS(STATIC_496), i121, i121)
R rules:

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
496_0_test_LE(EOS(STATIC_496), x0, x0) → 496_0_test_LE(EOS(STATIC_496), +(x0, -1), +(x0, -1)) | >(x0, 0)
R rules:

Filtered ground terms:

496_0_test_LE(x1, x2, x3) → 496_0_test_LE(x2, x3)
EOS(x1) → EOS
Cond_496_0_test_LE(x1, x2, x3, x4) → Cond_496_0_test_LE(x1, x3, x4)

Filtered duplicate args:

496_0_test_LE(x1, x2) → 496_0_test_LE(x2)
Cond_496_0_test_LE(x1, x2, x3) → Cond_496_0_test_LE(x1, x3)

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
496_0_test_LE(x0) → 496_0_test_LE(+(x0, -1)) | >(x0, 0)
R rules:

Finished conversion. Obtained 2 rules for P and 0 rules for R. System has predefined symbols.

P rules:
496_0_TEST_LE(x0) → COND_496_0_TEST_LE(>(x0, 0), x0)
COND_496_0_TEST_LE(TRUE, x0) → 496_0_TEST_LE(+(x0, -1))
R rules:

(84) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 496_0_TEST_LE(x0[0]) → COND_496_0_TEST_LE(x0[0] > 0, x0[0])
(1): COND_496_0_TEST_LE(TRUE, x0[1]) → 496_0_TEST_LE(x0[1] + -1)

(0) -> (1), if (x0[0] > 0 ∧x0[0] →^* x0[1])

(1) -> (0), if (x0[1] + -1 →^* x0[0])

The set Q is empty.

(85) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 496_0_TEST_LE(x0) → COND_496_0_TEST_LE(>(x0, 0), x0) the following chains were created:

• We consider the chain 496_0_TEST_LE(x0[0]) → COND_496_0_TEST_LE(>(x0[0], 0), x0[0]), COND_496_0_TEST_LE(TRUE, x0[1]) → 496_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (1)    (>(x0[0], 0)=TRUE∧x0[0]=x0[1] ⇒ 496_0_TEST_LE(x0[0])≥NonInfC∧496_0_TEST_LE(x0[0])≥COND_496_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_496_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (>(x0[0], 0)=TRUE ⇒ 496_0_TEST_LE(x0[0])≥NonInfC∧496_0_TEST_LE(x0[0])≥COND_496_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_496_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_496_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_496_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_496_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (6)    (x0[0] ≥ 0 ⇒ (U^Increasing(COND_496_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  

For Pair COND_496_0_TEST_LE(TRUE, x0) → 496_0_TEST_LE(+(x0, -1)) the following chains were created:

• We consider the chain COND_496_0_TEST_LE(TRUE, x0[1]) → 496_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (7)    (COND_496_0_TEST_LE(TRUE, x0[1])≥NonInfC∧COND_496_0_TEST_LE(TRUE, x0[1])≥496_0_TEST_LE(+(x0[1], -1))∧(U^Increasing(496_0_TEST_LE(+(x0[1], -1))), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    ((U^Increasing(496_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    ((U^Increasing(496_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    ((U^Increasing(496_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (11)    ((U^Increasing(496_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 496_0_TEST_LE(x0) → COND_496_0_TEST_LE(>(x0, 0), x0)
  
  • (x0[0] ≥ 0 ⇒ (U^Increasing(COND_496_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)
    
  
  
• COND_496_0_TEST_LE(TRUE, x0) → 496_0_TEST_LE(+(x0, -1))
  
  • ((U^Increasing(496_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(496_0_TEST_LE(x₁)) = [2]x₁   
POL(COND_496_0_TEST_LE(x₁, x₂)) = [2]x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   

The following pairs are in P_>:

COND_496_0_TEST_LE(TRUE, x0[1]) → 496_0_TEST_LE(+(x0[1], -1))

The following pairs are in P_bound:

496_0_TEST_LE(x0[0]) → COND_496_0_TEST_LE(>(x0[0], 0), x0[0])

The following pairs are in P_≥:

496_0_TEST_LE(x0[0]) → COND_496_0_TEST_LE(>(x0[0], 0), x0[0])

There are no usable rules.

(86) Complex Obligation (AND)

(87) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 496_0_TEST_LE(x0[0]) → COND_496_0_TEST_LE(x0[0] > 0, x0[0])


The set Q is empty.

(88) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(89) TRUE

(90) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_496_0_TEST_LE(TRUE, x0[1]) → 496_0_TEST_LE(x0[1] + -1)


The set Q is empty.

(91) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(92) TRUE

(93) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.test(I)V
SCC calls the following helper methods:
Performed SCC analyses: UsedFieldsAnalysis

(94) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 6 rules for P and 0 rules for R.

P rules:
456_0_test_LE(EOS(STATIC_456), i115, i115) → 460_0_test_LE(EOS(STATIC_460), i115, i115)
460_0_test_LE(EOS(STATIC_460), i115, i115) → 464_0_test_Inc(EOS(STATIC_464), i115) | >(i115, 0)
464_0_test_Inc(EOS(STATIC_464), i115) → 470_0_test_JMP(EOS(STATIC_470), +(i115, -1)) | >(i115, 0)
470_0_test_JMP(EOS(STATIC_470), i118) → 476_0_test_Load(EOS(STATIC_476), i118)
476_0_test_Load(EOS(STATIC_476), i118) → 452_0_test_Load(EOS(STATIC_452), i118)
452_0_test_Load(EOS(STATIC_452), i108) → 456_0_test_LE(EOS(STATIC_456), i108, i108)
R rules:

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
456_0_test_LE(EOS(STATIC_456), x0, x0) → 456_0_test_LE(EOS(STATIC_456), +(x0, -1), +(x0, -1)) | >(x0, 0)
R rules:

Filtered ground terms:

456_0_test_LE(x1, x2, x3) → 456_0_test_LE(x2, x3)
EOS(x1) → EOS
Cond_456_0_test_LE(x1, x2, x3, x4) → Cond_456_0_test_LE(x1, x3, x4)

Filtered duplicate args:

456_0_test_LE(x1, x2) → 456_0_test_LE(x2)
Cond_456_0_test_LE(x1, x2, x3) → Cond_456_0_test_LE(x1, x3)

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
456_0_test_LE(x0) → 456_0_test_LE(+(x0, -1)) | >(x0, 0)
R rules:

Finished conversion. Obtained 2 rules for P and 0 rules for R. System has predefined symbols.

P rules:
456_0_TEST_LE(x0) → COND_456_0_TEST_LE(>(x0, 0), x0)
COND_456_0_TEST_LE(TRUE, x0) → 456_0_TEST_LE(+(x0, -1))
R rules:

(95) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 456_0_TEST_LE(x0[0]) → COND_456_0_TEST_LE(x0[0] > 0, x0[0])
(1): COND_456_0_TEST_LE(TRUE, x0[1]) → 456_0_TEST_LE(x0[1] + -1)

(0) -> (1), if (x0[0] > 0 ∧x0[0] →^* x0[1])

(1) -> (0), if (x0[1] + -1 →^* x0[0])

The set Q is empty.

(96) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 456_0_TEST_LE(x0) → COND_456_0_TEST_LE(>(x0, 0), x0) the following chains were created:

• We consider the chain 456_0_TEST_LE(x0[0]) → COND_456_0_TEST_LE(>(x0[0], 0), x0[0]), COND_456_0_TEST_LE(TRUE, x0[1]) → 456_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (1)    (>(x0[0], 0)=TRUE∧x0[0]=x0[1] ⇒ 456_0_TEST_LE(x0[0])≥NonInfC∧456_0_TEST_LE(x0[0])≥COND_456_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_456_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (>(x0[0], 0)=TRUE ⇒ 456_0_TEST_LE(x0[0])≥NonInfC∧456_0_TEST_LE(x0[0])≥COND_456_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_456_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_456_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_456_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_456_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (6)    (x0[0] ≥ 0 ⇒ (U^Increasing(COND_456_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  

For Pair COND_456_0_TEST_LE(TRUE, x0) → 456_0_TEST_LE(+(x0, -1)) the following chains were created:

• We consider the chain COND_456_0_TEST_LE(TRUE, x0[1]) → 456_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (7)    (COND_456_0_TEST_LE(TRUE, x0[1])≥NonInfC∧COND_456_0_TEST_LE(TRUE, x0[1])≥456_0_TEST_LE(+(x0[1], -1))∧(U^Increasing(456_0_TEST_LE(+(x0[1], -1))), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    ((U^Increasing(456_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    ((U^Increasing(456_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    ((U^Increasing(456_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (11)    ((U^Increasing(456_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 456_0_TEST_LE(x0) → COND_456_0_TEST_LE(>(x0, 0), x0)
  
  • (x0[0] ≥ 0 ⇒ (U^Increasing(COND_456_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)
    
  
  
• COND_456_0_TEST_LE(TRUE, x0) → 456_0_TEST_LE(+(x0, -1))
  
  • ((U^Increasing(456_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(456_0_TEST_LE(x₁)) = [2]x₁   
POL(COND_456_0_TEST_LE(x₁, x₂)) = [2]x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   

The following pairs are in P_>:

COND_456_0_TEST_LE(TRUE, x0[1]) → 456_0_TEST_LE(+(x0[1], -1))

The following pairs are in P_bound:

456_0_TEST_LE(x0[0]) → COND_456_0_TEST_LE(>(x0[0], 0), x0[0])

The following pairs are in P_≥:

456_0_TEST_LE(x0[0]) → COND_456_0_TEST_LE(>(x0[0], 0), x0[0])

There are no usable rules.

(97) Complex Obligation (AND)

(98) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 456_0_TEST_LE(x0[0]) → COND_456_0_TEST_LE(x0[0] > 0, x0[0])


The set Q is empty.

(99) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(100) TRUE

(101) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_456_0_TEST_LE(TRUE, x0[1]) → 456_0_TEST_LE(x0[1] + -1)


The set Q is empty.

(102) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(103) TRUE

(104) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.test(I)V
SCC calls the following helper methods:
Performed SCC analyses: UsedFieldsAnalysis

(105) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 6 rules for P and 0 rules for R.

P rules:
416_0_test_LE(EOS(STATIC_416), i102, i102) → 419_0_test_LE(EOS(STATIC_419), i102, i102)
419_0_test_LE(EOS(STATIC_419), i102, i102) → 423_0_test_Inc(EOS(STATIC_423), i102) | >(i102, 0)
423_0_test_Inc(EOS(STATIC_423), i102) → 428_0_test_JMP(EOS(STATIC_428), +(i102, -1)) | >(i102, 0)
428_0_test_JMP(EOS(STATIC_428), i103) → 435_0_test_Load(EOS(STATIC_435), i103)
435_0_test_Load(EOS(STATIC_435), i103) → 413_0_test_Load(EOS(STATIC_413), i103)
413_0_test_Load(EOS(STATIC_413), i98) → 416_0_test_LE(EOS(STATIC_416), i98, i98)
R rules:

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
416_0_test_LE(EOS(STATIC_416), x0, x0) → 416_0_test_LE(EOS(STATIC_416), +(x0, -1), +(x0, -1)) | >(x0, 0)
R rules:

Filtered ground terms:

416_0_test_LE(x1, x2, x3) → 416_0_test_LE(x2, x3)
EOS(x1) → EOS
Cond_416_0_test_LE(x1, x2, x3, x4) → Cond_416_0_test_LE(x1, x3, x4)

Filtered duplicate args:

416_0_test_LE(x1, x2) → 416_0_test_LE(x2)
Cond_416_0_test_LE(x1, x2, x3) → Cond_416_0_test_LE(x1, x3)

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
416_0_test_LE(x0) → 416_0_test_LE(+(x0, -1)) | >(x0, 0)
R rules:

Finished conversion. Obtained 2 rules for P and 0 rules for R. System has predefined symbols.

P rules:
416_0_TEST_LE(x0) → COND_416_0_TEST_LE(>(x0, 0), x0)
COND_416_0_TEST_LE(TRUE, x0) → 416_0_TEST_LE(+(x0, -1))
R rules:

(106) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 416_0_TEST_LE(x0[0]) → COND_416_0_TEST_LE(x0[0] > 0, x0[0])
(1): COND_416_0_TEST_LE(TRUE, x0[1]) → 416_0_TEST_LE(x0[1] + -1)

(0) -> (1), if (x0[0] > 0 ∧x0[0] →^* x0[1])

(1) -> (0), if (x0[1] + -1 →^* x0[0])

The set Q is empty.

(107) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 416_0_TEST_LE(x0) → COND_416_0_TEST_LE(>(x0, 0), x0) the following chains were created:

• We consider the chain 416_0_TEST_LE(x0[0]) → COND_416_0_TEST_LE(>(x0[0], 0), x0[0]), COND_416_0_TEST_LE(TRUE, x0[1]) → 416_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (1)    (>(x0[0], 0)=TRUE∧x0[0]=x0[1] ⇒ 416_0_TEST_LE(x0[0])≥NonInfC∧416_0_TEST_LE(x0[0])≥COND_416_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_416_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (>(x0[0], 0)=TRUE ⇒ 416_0_TEST_LE(x0[0])≥NonInfC∧416_0_TEST_LE(x0[0])≥COND_416_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_416_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_416_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_416_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_416_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (6)    (x0[0] ≥ 0 ⇒ (U^Increasing(COND_416_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  

For Pair COND_416_0_TEST_LE(TRUE, x0) → 416_0_TEST_LE(+(x0, -1)) the following chains were created:

• We consider the chain COND_416_0_TEST_LE(TRUE, x0[1]) → 416_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (7)    (COND_416_0_TEST_LE(TRUE, x0[1])≥NonInfC∧COND_416_0_TEST_LE(TRUE, x0[1])≥416_0_TEST_LE(+(x0[1], -1))∧(U^Increasing(416_0_TEST_LE(+(x0[1], -1))), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    ((U^Increasing(416_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    ((U^Increasing(416_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    ((U^Increasing(416_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (11)    ((U^Increasing(416_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 416_0_TEST_LE(x0) → COND_416_0_TEST_LE(>(x0, 0), x0)
  
  • (x0[0] ≥ 0 ⇒ (U^Increasing(COND_416_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)
    
  
  
• COND_416_0_TEST_LE(TRUE, x0) → 416_0_TEST_LE(+(x0, -1))
  
  • ((U^Increasing(416_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(416_0_TEST_LE(x₁)) = [2]x₁   
POL(COND_416_0_TEST_LE(x₁, x₂)) = [2]x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   

The following pairs are in P_>:

COND_416_0_TEST_LE(TRUE, x0[1]) → 416_0_TEST_LE(+(x0[1], -1))

The following pairs are in P_bound:

416_0_TEST_LE(x0[0]) → COND_416_0_TEST_LE(>(x0[0], 0), x0[0])

The following pairs are in P_≥:

416_0_TEST_LE(x0[0]) → COND_416_0_TEST_LE(>(x0[0], 0), x0[0])

There are no usable rules.

(108) Complex Obligation (AND)

(109) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 416_0_TEST_LE(x0[0]) → COND_416_0_TEST_LE(x0[0] > 0, x0[0])


The set Q is empty.

(110) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(111) TRUE

(112) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_416_0_TEST_LE(TRUE, x0[1]) → 416_0_TEST_LE(x0[1] + -1)


The set Q is empty.

(113) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(114) TRUE

(115) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.test(I)V
SCC calls the following helper methods:
Performed SCC analyses: UsedFieldsAnalysis

(116) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 6 rules for P and 0 rules for R.

P rules:
389_0_test_LE(EOS(STATIC_389), i91, i91) → 392_0_test_LE(EOS(STATIC_392), i91, i91)
392_0_test_LE(EOS(STATIC_392), i91, i91) → 396_0_test_Inc(EOS(STATIC_396), i91) | >(i91, 0)
396_0_test_Inc(EOS(STATIC_396), i91) → 400_0_test_JMP(EOS(STATIC_400), +(i91, -1)) | >(i91, 0)
400_0_test_JMP(EOS(STATIC_400), i94) → 405_0_test_Load(EOS(STATIC_405), i94)
405_0_test_Load(EOS(STATIC_405), i94) → 386_0_test_Load(EOS(STATIC_386), i94)
386_0_test_Load(EOS(STATIC_386), i86) → 389_0_test_LE(EOS(STATIC_389), i86, i86)
R rules:

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
389_0_test_LE(EOS(STATIC_389), x0, x0) → 389_0_test_LE(EOS(STATIC_389), +(x0, -1), +(x0, -1)) | >(x0, 0)
R rules:

Filtered ground terms:

389_0_test_LE(x1, x2, x3) → 389_0_test_LE(x2, x3)
EOS(x1) → EOS
Cond_389_0_test_LE(x1, x2, x3, x4) → Cond_389_0_test_LE(x1, x3, x4)

Filtered duplicate args:

389_0_test_LE(x1, x2) → 389_0_test_LE(x2)
Cond_389_0_test_LE(x1, x2, x3) → Cond_389_0_test_LE(x1, x3)

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
389_0_test_LE(x0) → 389_0_test_LE(+(x0, -1)) | >(x0, 0)
R rules:

Finished conversion. Obtained 2 rules for P and 0 rules for R. System has predefined symbols.

P rules:
389_0_TEST_LE(x0) → COND_389_0_TEST_LE(>(x0, 0), x0)
COND_389_0_TEST_LE(TRUE, x0) → 389_0_TEST_LE(+(x0, -1))
R rules:

(117) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 389_0_TEST_LE(x0[0]) → COND_389_0_TEST_LE(x0[0] > 0, x0[0])
(1): COND_389_0_TEST_LE(TRUE, x0[1]) → 389_0_TEST_LE(x0[1] + -1)

(0) -> (1), if (x0[0] > 0 ∧x0[0] →^* x0[1])

(1) -> (0), if (x0[1] + -1 →^* x0[0])

The set Q is empty.

(118) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 389_0_TEST_LE(x0) → COND_389_0_TEST_LE(>(x0, 0), x0) the following chains were created:

• We consider the chain 389_0_TEST_LE(x0[0]) → COND_389_0_TEST_LE(>(x0[0], 0), x0[0]), COND_389_0_TEST_LE(TRUE, x0[1]) → 389_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (1)    (>(x0[0], 0)=TRUE∧x0[0]=x0[1] ⇒ 389_0_TEST_LE(x0[0])≥NonInfC∧389_0_TEST_LE(x0[0])≥COND_389_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_389_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (>(x0[0], 0)=TRUE ⇒ 389_0_TEST_LE(x0[0])≥NonInfC∧389_0_TEST_LE(x0[0])≥COND_389_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_389_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_389_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_389_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_389_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (6)    (x0[0] ≥ 0 ⇒ (U^Increasing(COND_389_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  

For Pair COND_389_0_TEST_LE(TRUE, x0) → 389_0_TEST_LE(+(x0, -1)) the following chains were created:

• We consider the chain COND_389_0_TEST_LE(TRUE, x0[1]) → 389_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (7)    (COND_389_0_TEST_LE(TRUE, x0[1])≥NonInfC∧COND_389_0_TEST_LE(TRUE, x0[1])≥389_0_TEST_LE(+(x0[1], -1))∧(U^Increasing(389_0_TEST_LE(+(x0[1], -1))), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    ((U^Increasing(389_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    ((U^Increasing(389_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    ((U^Increasing(389_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (11)    ((U^Increasing(389_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 389_0_TEST_LE(x0) → COND_389_0_TEST_LE(>(x0, 0), x0)
  
  • (x0[0] ≥ 0 ⇒ (U^Increasing(COND_389_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)
    
  
  
• COND_389_0_TEST_LE(TRUE, x0) → 389_0_TEST_LE(+(x0, -1))
  
  • ((U^Increasing(389_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(389_0_TEST_LE(x₁)) = [2]x₁   
POL(COND_389_0_TEST_LE(x₁, x₂)) = [2]x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   

The following pairs are in P_>:

COND_389_0_TEST_LE(TRUE, x0[1]) → 389_0_TEST_LE(+(x0[1], -1))

The following pairs are in P_bound:

389_0_TEST_LE(x0[0]) → COND_389_0_TEST_LE(>(x0[0], 0), x0[0])

The following pairs are in P_≥:

389_0_TEST_LE(x0[0]) → COND_389_0_TEST_LE(>(x0[0], 0), x0[0])

There are no usable rules.

(119) Complex Obligation (AND)

(120) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 389_0_TEST_LE(x0[0]) → COND_389_0_TEST_LE(x0[0] > 0, x0[0])


The set Q is empty.

(121) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(122) TRUE

(123) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_389_0_TEST_LE(TRUE, x0[1]) → 389_0_TEST_LE(x0[1] + -1)


The set Q is empty.

(124) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(125) TRUE

(126) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.test(I)V
SCC calls the following helper methods:
Performed SCC analyses: UsedFieldsAnalysis

(127) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 6 rules for P and 0 rules for R.

P rules:
356_0_test_LE(EOS(STATIC_356), i79, i79) → 360_0_test_LE(EOS(STATIC_360), i79, i79)
360_0_test_LE(EOS(STATIC_360), i79, i79) → 364_0_test_Inc(EOS(STATIC_364), i79) | >(i79, 0)
364_0_test_Inc(EOS(STATIC_364), i79) → 368_0_test_JMP(EOS(STATIC_368), +(i79, -1)) | >(i79, 0)
368_0_test_JMP(EOS(STATIC_368), i81) → 373_0_test_Load(EOS(STATIC_373), i81)
373_0_test_Load(EOS(STATIC_373), i81) → 352_0_test_Load(EOS(STATIC_352), i81)
352_0_test_Load(EOS(STATIC_352), i73) → 356_0_test_LE(EOS(STATIC_356), i73, i73)
R rules:

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
356_0_test_LE(EOS(STATIC_356), x0, x0) → 356_0_test_LE(EOS(STATIC_356), +(x0, -1), +(x0, -1)) | >(x0, 0)
R rules:

Filtered ground terms:

356_0_test_LE(x1, x2, x3) → 356_0_test_LE(x2, x3)
EOS(x1) → EOS
Cond_356_0_test_LE(x1, x2, x3, x4) → Cond_356_0_test_LE(x1, x3, x4)

Filtered duplicate args:

356_0_test_LE(x1, x2) → 356_0_test_LE(x2)
Cond_356_0_test_LE(x1, x2, x3) → Cond_356_0_test_LE(x1, x3)

Combined rules. Obtained 1 conditional rules for P and 0 conditional rules for R.

P rules:
356_0_test_LE(x0) → 356_0_test_LE(+(x0, -1)) | >(x0, 0)
R rules:

Finished conversion. Obtained 2 rules for P and 0 rules for R. System has predefined symbols.

P rules:
356_0_TEST_LE(x0) → COND_356_0_TEST_LE(>(x0, 0), x0)
COND_356_0_TEST_LE(TRUE, x0) → 356_0_TEST_LE(+(x0, -1))
R rules:

(128) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 356_0_TEST_LE(x0[0]) → COND_356_0_TEST_LE(x0[0] > 0, x0[0])
(1): COND_356_0_TEST_LE(TRUE, x0[1]) → 356_0_TEST_LE(x0[1] + -1)

(0) -> (1), if (x0[0] > 0 ∧x0[0] →^* x0[1])

(1) -> (0), if (x0[1] + -1 →^* x0[0])

The set Q is empty.

(129) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 356_0_TEST_LE(x0) → COND_356_0_TEST_LE(>(x0, 0), x0) the following chains were created:

• We consider the chain 356_0_TEST_LE(x0[0]) → COND_356_0_TEST_LE(>(x0[0], 0), x0[0]), COND_356_0_TEST_LE(TRUE, x0[1]) → 356_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (1)    (>(x0[0], 0)=TRUE∧x0[0]=x0[1] ⇒ 356_0_TEST_LE(x0[0])≥NonInfC∧356_0_TEST_LE(x0[0])≥COND_356_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_356_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (>(x0[0], 0)=TRUE ⇒ 356_0_TEST_LE(x0[0])≥NonInfC∧356_0_TEST_LE(x0[0])≥COND_356_0_TEST_LE(>(x0[0], 0), x0[0])∧(U^Increasing(COND_356_0_TEST_LE(>(x0[0], 0), x0[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_356_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_356_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    (x0[0] + [-1] ≥ 0 ⇒ (U^Increasing(COND_356_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (6)    (x0[0] ≥ 0 ⇒ (U^Increasing(COND_356_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)

  
  
  

For Pair COND_356_0_TEST_LE(TRUE, x0) → 356_0_TEST_LE(+(x0, -1)) the following chains were created:

• We consider the chain COND_356_0_TEST_LE(TRUE, x0[1]) → 356_0_TEST_LE(+(x0[1], -1)) which results in the following constraint:
  

  (7)    (COND_356_0_TEST_LE(TRUE, x0[1])≥NonInfC∧COND_356_0_TEST_LE(TRUE, x0[1])≥356_0_TEST_LE(+(x0[1], -1))∧(U^Increasing(356_0_TEST_LE(+(x0[1], -1))), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    ((U^Increasing(356_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    ((U^Increasing(356_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    ((U^Increasing(356_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (11)    ((U^Increasing(356_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 356_0_TEST_LE(x0) → COND_356_0_TEST_LE(>(x0, 0), x0)
  
  • (x0[0] ≥ 0 ⇒ (U^Increasing(COND_356_0_TEST_LE(>(x0[0], 0), x0[0])), ≥)∧[(-1)Bound*bni_8 + (2)bni_8] + [(2)bni_8]x0[0] ≥ 0∧[(-1)bso_9] ≥ 0)
    
  
  
• COND_356_0_TEST_LE(TRUE, x0) → 356_0_TEST_LE(+(x0, -1))
  
  • ((U^Increasing(356_0_TEST_LE(+(x0[1], -1))), ≥)∧[bni_10] = 0∧0 = 0∧[2 + (-1)bso_11] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(356_0_TEST_LE(x₁)) = [2]x₁   
POL(COND_356_0_TEST_LE(x₁, x₂)) = [2]x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   

The following pairs are in P_>:

COND_356_0_TEST_LE(TRUE, x0[1]) → 356_0_TEST_LE(+(x0[1], -1))

The following pairs are in P_bound:

356_0_TEST_LE(x0[0]) → COND_356_0_TEST_LE(>(x0[0], 0), x0[0])

The following pairs are in P_≥:

356_0_TEST_LE(x0[0]) → COND_356_0_TEST_LE(>(x0[0], 0), x0[0])

There are no usable rules.

(130) Complex Obligation (AND)

(131) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(0): 356_0_TEST_LE(x0[0]) → COND_356_0_TEST_LE(x0[0] > 0, x0[0])


The set Q is empty.

(132) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(133) TRUE

(134) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_356_0_TEST_LE(TRUE, x0[1]) → 356_0_TEST_LE(x0[1] + -1)


The set Q is empty.

(135) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(136) TRUE

(137) Obligation:

SCC of termination graph based on JBC Program.
SCC contains nodes from the following methods: Test9.main([Ljava/lang/String;)V
SCC calls the following helper methods: Test9.test(I)V
Performed SCC analyses: UsedFieldsAnalysis

(138) SCCToIDPv1Proof (SOUND transformation)

Transformed FIGraph SCCs to IDPs. Log:

Generated 27 rules for P and 134 rules for R.

P rules:
62_0_main_ConstantStackPush(EOS(STATIC_62), i4, i4) → 64_0_main_Cmp(EOS(STATIC_64), i4, i4, 0)
64_0_main_Cmp(EOS(STATIC_64), i6, i6, matching1) → 68_0_main_Cmp(EOS(STATIC_68), i6, i6, 0) | =(matching1, 0)
68_0_main_Cmp(EOS(STATIC_68), i6, i6, matching1) → 76_0_main_LE(EOS(STATIC_76), i6, 1) | &&(>(i6, 0), =(matching1, 0))
76_0_main_LE(EOS(STATIC_76), i6, matching1) → 80_0_main_Load(EOS(STATIC_80), i6) | &&(>(1, 0), =(matching1, 1))
80_0_main_Load(EOS(STATIC_80), i6) → 84_0_main_TypeCast(EOS(STATIC_84), i6, i6)
84_0_main_TypeCast(EOS(STATIC_84), i6, i6) → 86_0_main_Store(EOS(STATIC_86), i6, i10) | =(i10, i6)
86_0_main_Store(EOS(STATIC_86), i6, i10) → 88_0_main_Load(EOS(STATIC_88), i6, i10)
88_0_main_Load(EOS(STATIC_88), i6, i10) → 89_0_main_ConstantStackPush(EOS(STATIC_89), i6, i10, i10)
89_0_main_ConstantStackPush(EOS(STATIC_89), i6, i10, i10) → 90_0_main_GE(EOS(STATIC_90), i6, i10, i10, 100)
90_0_main_GE(EOS(STATIC_90), i6, i13, i13, matching1) → 91_0_main_GE(EOS(STATIC_91), i6, i13, i13, 100) | =(matching1, 100)
90_0_main_GE(EOS(STATIC_90), i6, i14, i14, matching1) → 92_0_main_GE(EOS(STATIC_92), i6, i14, i14, 100) | =(matching1, 100)
91_0_main_GE(EOS(STATIC_91), i6, i13, i13, matching1) → 93_0_main_Load(EOS(STATIC_93), i6, i13) | &&(<(i13, 100), =(matching1, 100))
93_0_main_Load(EOS(STATIC_93), i6, i13) → 95_0_main_InvokeMethod(EOS(STATIC_95), i6, i13, i13)
95_0_main_InvokeMethod(EOS(STATIC_95), i6, i13, i13) → 97_1_main_InvokeMethod(97_0_test_Load(EOS(STATIC_97), i13), i6, i13, i13)
97_1_main_InvokeMethod(751_0_test_Return(EOS(STATIC_751)), i6, i215, i215) → 771_0_test_Return(EOS(STATIC_771), i6, i215, i215)
771_0_test_Return(EOS(STATIC_771), i6, i215, i215) → 774_0_main_Inc(EOS(STATIC_774), i6, i215)
774_0_main_Inc(EOS(STATIC_774), i6, i215) → 776_0_main_JMP(EOS(STATIC_776), i6, +(i215, 1)) | >(i215, 0)
776_0_main_JMP(EOS(STATIC_776), i6, i221) → 780_0_main_Load(EOS(STATIC_780), i6, i221)
780_0_main_Load(EOS(STATIC_780), i6, i221) → 88_0_main_Load(EOS(STATIC_88), i6, i221)
92_0_main_GE(EOS(STATIC_92), i6, i14, i14, matching1) → 94_0_main_Load(EOS(STATIC_94), i6) | &&(>=(i14, 100), =(matching1, 100))
94_0_main_Load(EOS(STATIC_94), i6) → 96_0_main_ConstantStackPush(EOS(STATIC_96), i6)
96_0_main_ConstantStackPush(EOS(STATIC_96), i6) → 100_0_main_IntArithmetic(EOS(STATIC_100), i6, 1)
100_0_main_IntArithmetic(EOS(STATIC_100), i6, matching1) → 104_0_main_Store(EOS(STATIC_104), -(i6, 1)) | &&(>(i6, 0), =(matching1, 1))
104_0_main_Store(EOS(STATIC_104), i16) → 108_0_main_JMP(EOS(STATIC_108), i16)
108_0_main_JMP(EOS(STATIC_108), i16) → 128_0_main_Load(EOS(STATIC_128), i16)
128_0_main_Load(EOS(STATIC_128), i16) → 60_0_main_Load(EOS(STATIC_60), i16)
60_0_main_Load(EOS(STATIC_60), i4) → 62_0_main_ConstantStackPush(EOS(STATIC_62), i4, i4)
R rules:
97_0_test_Load(EOS(STATIC_97), i13) → 102_0_test_Load(EOS(STATIC_102), i13)
102_0_test_Load(EOS(STATIC_102), i13) → 110_0_test_Load(EOS(STATIC_110), i13)
110_0_test_Load(EOS(STATIC_110), i13) → 131_0_test_Store(EOS(STATIC_131), i13, i13)
131_0_test_Store(EOS(STATIC_131), i13, i13) → 335_0_test_Load(EOS(STATIC_335), i13, i13)
335_0_test_Load(EOS(STATIC_335), i13, i13) → 352_0_test_Load(EOS(STATIC_352), i13, i13)
352_0_test_Load(EOS(STATIC_352), i13, i73) → 356_0_test_LE(EOS(STATIC_356), i13, i73, i73)
356_0_test_LE(EOS(STATIC_356), i13, matching1, matching2) → 359_0_test_LE(EOS(STATIC_359), i13, 0, 0) | &&(=(matching1, 0), =(matching2, 0))
356_0_test_LE(EOS(STATIC_356), i13, i79, i79) → 360_0_test_LE(EOS(STATIC_360), i13, i79, i79)
359_0_test_LE(EOS(STATIC_359), i13, matching1, matching2) → 361_0_test_Load(EOS(STATIC_361), i13) | &&(&&(<=(0, 0), =(matching1, 0)), =(matching2, 0))
360_0_test_LE(EOS(STATIC_360), i13, i79, i79) → 364_0_test_Inc(EOS(STATIC_364), i13, i79) | >(i79, 0)
361_0_test_Load(EOS(STATIC_361), i13) → 366_0_test_Store(EOS(STATIC_366), i13, i13)
364_0_test_Inc(EOS(STATIC_364), i13, i79) → 368_0_test_JMP(EOS(STATIC_368), i13, +(i79, -1)) | >(i79, 0)
366_0_test_Store(EOS(STATIC_366), i13, i13) → 370_0_test_Load(EOS(STATIC_370), i13, i13)
368_0_test_JMP(EOS(STATIC_368), i13, i81) → 373_0_test_Load(EOS(STATIC_373), i13, i81)
370_0_test_Load(EOS(STATIC_370), i13, i13) → 386_0_test_Load(EOS(STATIC_386), i13, i13)
373_0_test_Load(EOS(STATIC_373), i13, i81) → 352_0_test_Load(EOS(STATIC_352), i13, i81)
386_0_test_Load(EOS(STATIC_386), i13, i86) → 389_0_test_LE(EOS(STATIC_389), i13, i86, i86)
389_0_test_LE(EOS(STATIC_389), i13, matching1, matching2) → 391_0_test_LE(EOS(STATIC_391), i13, 0, 0) | &&(=(matching1, 0), =(matching2, 0))
389_0_test_LE(EOS(STATIC_389), i13, i91, i91) → 392_0_test_LE(EOS(STATIC_392), i13, i91, i91)
391_0_test_LE(EOS(STATIC_391), i13, matching1, matching2) → 394_0_test_Load(EOS(STATIC_394), i13) | &&(&&(<=(0, 0), =(matching1, 0)), =(matching2, 0))
392_0_test_LE(EOS(STATIC_392), i13, i91, i91) → 396_0_test_Inc(EOS(STATIC_396), i13, i91) | >(i91, 0)
394_0_test_Load(EOS(STATIC_394), i13) → 398_0_test_Store(EOS(STATIC_398), i13, i13)
396_0_test_Inc(EOS(STATIC_396), i13, i91) → 400_0_test_JMP(EOS(STATIC_400), i13, +(i91, -1)) | >(i91, 0)
398_0_test_Store(EOS(STATIC_398), i13, i13) → 401_0_test_Load(EOS(STATIC_401), i13, i13)
400_0_test_JMP(EOS(STATIC_400), i13, i94) → 405_0_test_Load(EOS(STATIC_405), i13, i94)
401_0_test_Load(EOS(STATIC_401), i13, i13) → 413_0_test_Load(EOS(STATIC_413), i13, i13)
405_0_test_Load(EOS(STATIC_405), i13, i94) → 386_0_test_Load(EOS(STATIC_386), i13, i94)
413_0_test_Load(EOS(STATIC_413), i13, i98) → 416_0_test_LE(EOS(STATIC_416), i13, i98, i98)
416_0_test_LE(EOS(STATIC_416), i13, matching1, matching2) → 418_0_test_LE(EOS(STATIC_418), i13, 0, 0) | &&(=(matching1, 0), =(matching2, 0))
416_0_test_LE(EOS(STATIC_416), i13, i102, i102) → 419_0_test_LE(EOS(STATIC_419), i13, i102, i102)
418_0_test_LE(EOS(STATIC_418), i13, matching1, matching2) → 421_0_test_Load(EOS(STATIC_421), i13) | &&(&&(<=(0, 0), =(matching1, 0)), =(matching2, 0))
419_0_test_LE(EOS(STATIC_419), i13, i102, i102) → 423_0_test_Inc(EOS(STATIC_423), i13, i102) | >(i102, 0)
421_0_test_Load(EOS(STATIC_421), i13) → 426_0_test_Store(EOS(STATIC_426), i13, i13)
423_0_test_Inc(EOS(STATIC_423), i13, i102) → 428_0_test_JMP(EOS(STATIC_428), i13, +(i102, -1)) | >(i102, 0)
426_0_test_Store(EOS(STATIC_426), i13, i13) → 431_0_test_Load(EOS(STATIC_431), i13, i13)
428_0_test_JMP(EOS(STATIC_428), i13, i103) → 435_0_test_Load(EOS(STATIC_435), i13, i103)
431_0_test_Load(EOS(STATIC_431), i13, i13) → 452_0_test_Load(EOS(STATIC_452), i13, i13)
435_0_test_Load(EOS(STATIC_435), i13, i103) → 413_0_test_Load(EOS(STATIC_413), i13, i103)
452_0_test_Load(EOS(STATIC_452), i13, i108) → 456_0_test_LE(EOS(STATIC_456), i13, i108, i108)
456_0_test_LE(EOS(STATIC_456), i13, matching1, matching2) → 459_0_test_LE(EOS(STATIC_459), i13, 0, 0) | &&(=(matching1, 0), =(matching2, 0))
456_0_test_LE(EOS(STATIC_456), i13, i115, i115) → 460_0_test_LE(EOS(STATIC_460), i13, i115, i115)
459_0_test_LE(EOS(STATIC_459), i13, matching1, matching2) → 462_0_test_Load(EOS(STATIC_462), i13) | &&(&&(<=(0, 0), =(matching1, 0)), =(matching2, 0))
460_0_test_LE(EOS(STATIC_460), i13, i115, i115) → 464_0_test_Inc(EOS(STATIC_464), i13, i115) | >(i115, 0)
462_0_test_Load(EOS(STATIC_462), i13) → 466_0_test_Store(EOS(STATIC_466), i13, i13)
464_0_test_Inc(EOS(STATIC_464), i13, i115) → 470_0_test_JMP(EOS(STATIC_470), i13, +(i115, -1)) | >(i115, 0)
466_0_test_Store(EOS(STATIC_466), i13, i13) → 472_0_test_Load(EOS(STATIC_472), i13, i13)
470_0_test_JMP(EOS(STATIC_470), i13, i118) → 476_0_test_Load(EOS(STATIC_476), i13, i118)
472_0_test_Load(EOS(STATIC_472), i13, i13) → 493_0_test_Load(EOS(STATIC_493), i13, i13)
476_0_test_Load(EOS(STATIC_476), i13, i118) → 452_0_test_Load(EOS(STATIC_452), i13, i118)
493_0_test_Load(EOS(STATIC_493), i13, i121) → 496_0_test_LE(EOS(STATIC_496), i13, i121, i121)
496_0_test_LE(EOS(STATIC_496), i13, matching1, matching2) → 499_0_test_LE(EOS(STATIC_499), i13, 0, 0) | &&(=(matching1, 0), =(matching2, 0))
496_0_test_LE(EOS(STATIC_496), i13, i125, i125) → 500_0_test_LE(EOS(STATIC_500), i13, i125, i125)
499_0_test_LE(EOS(STATIC_499), i13, matching1, matching2) → 502_0_test_Load(EOS(STATIC_502), i13) | &&(&&(<=(0, 0), =(matching1, 0)), =(matching2, 0))
500_0_test_LE(EOS(STATIC_500), i13, i125, i125) → 504_0_test_Inc(EOS(STATIC_504), i13, i125) | >(i125, 0)
502_0_test_Load(EOS(STATIC_502), i13) → 507_0_test_Store(EOS(STATIC_507), i13, i13)
504_0_test_Inc(EOS(STATIC_504), i13, i125) → 509_0_test_JMP(EOS(STATIC_509), i13, +(i125, -1)) | >(i125, 0)
507_0_test_Store(EOS(STATIC_507), i13, i13) → 511_0_test_Load(EOS(STATIC_511), i13, i13)
509_0_test_JMP(EOS(STATIC_509), i13, i127) → 514_0_test_Load(EOS(STATIC_514), i13, i127)
511_0_test_Load(EOS(STATIC_511), i13, i13) → 525_0_test_Load(EOS(STATIC_525), i13, i13)
514_0_test_Load(EOS(STATIC_514), i13, i127) → 493_0_test_Load(EOS(STATIC_493), i13, i127)
525_0_test_Load(EOS(STATIC_525), i13, i131) → 528_0_test_LE(EOS(STATIC_528), i13, i131, i131)
528_0_test_LE(EOS(STATIC_528), i13, matching1, matching2) → 530_0_test_LE(EOS(STATIC_530), i13, 0, 0) | &&(=(matching1, 0), =(matching2, 0))
528_0_test_LE(EOS(STATIC_528), i13, i136, i136) → 531_0_test_LE(EOS(STATIC_531), i13, i136, i136)
530_0_test_LE(EOS(STATIC_530), i13, matching1, matching2) → 533_0_test_Load(EOS(STATIC_533), i13) | &&(&&(<=(0, 0), =(matching1, 0)), =(matching2, 0))
531_0_test_LE(EOS(STATIC_531), i13, i136, i136) → 535_0_test_Inc(EOS(STATIC_535), i13, i136) | >(i136, 0)
533_0_test_Load(EOS(STATIC_533), i13) → 536_0_test_Store(EOS(STATIC_536), i13, i13)
535_0_test_Inc(EOS(STATIC_535), i13, i136) → 539_0_test_JMP(EOS(STATIC_539), i13, +(i136, -1)) | >(i136, 0)
536_0_test_Store(EOS(STATIC_536), i13, i13) → 540_0_test_Load(EOS(STATIC_540), i13, i13)
539_0_test_JMP(EOS(STATIC_539), i13, i138) → 545_0_test_Load(EOS(STATIC_545), i13, i138)
540_0_test_Load(EOS(STATIC_540), i13, i13) → 561_0_test_Load(EOS(STATIC_561), i13, i13)
545_0_test_Load(EOS(STATIC_545), i13, i138) → 525_0_test_Load(EOS(STATIC_525), i13, i138)
561_0_test_Load(EOS(STATIC_561), i13, i143) → 564_0_test_LE(EOS(STATIC_564), i13, i143, i143)
564_0_test_LE(EOS(STATIC_564), i13, matching1, matching2) → 566_0_test_LE(EOS(STATIC_566), i13, 0, 0) | &&(=(matching1, 0), =(matching2, 0))
564_0_test_LE(EOS(STATIC_564), i13, i148, i148) → 568_0_test_LE(EOS(STATIC_568), i13, i148, i148)
566_0_test_LE(EOS(STATIC_566), i13, matching1, matching2) → 570_0_test_Load(EOS(STATIC_570), i13) | &&(&&(<=(0, 0), =(matching1, 0)), =(matching2, 0))
568_0_test_LE(EOS(STATIC_568), i13, i148, i148) → 572_0_test_Inc(EOS(STATIC_572), i13, i148) | >(i148, 0)
570_0_test_Load(EOS(STATIC_570), i13) → 574_0_test_Store(EOS(STATIC_574), i13, i13)
572_0_test_Inc(EOS(STATIC_572), i13, i148) → 577_0_test_JMP(EOS(STATIC_577), i13, +(i148, -1)) | >(i148, 0)
574_0_test_Store(EOS(STATIC_574), i13, i13) → 579_0_test_Load(EOS(STATIC_579), i13, i13)
577_0_test_JMP(EOS(STATIC_577), i13, i151) → 583_0_test_Load(EOS(STATIC_583), i13, i151)
579_0_test_Load(EOS(STATIC_579), i13, i13) → 598_0_test_Load(EOS(STATIC_598), i13, i13)
583_0_test_Load(EOS(STATIC_583), i13, i151) → 561_0_test_Load(EOS(STATIC_561), i13, i151)
598_0_test_Load(EOS(STATIC_598), i13, i157) → 602_0_test_LE(EOS(STATIC_602), i13, i157, i157)
602_0_test_LE(EOS(STATIC_602), i13, matching1, matching2) → 604_0_test_LE(EOS(STATIC_604), i13, 0, 0) | &&(=(matching1, 0), =(matching2, 0))
602_0_test_LE(EOS(STATIC_602), i13, i161, i161) → 606_0_test_LE(EOS(STATIC_606), i13, i161, i161)
604_0_test_LE(EOS(STATIC_604), i13, matching1, matching2) → 608_0_test_Load(EOS(STATIC_608), i13) | &&(&&(<=(0, 0), =(matching1, 0)), =(matching2, 0))
606_0_test_LE(EOS(STATIC_606), i13, i161, i161) → 610_0_test_Inc(EOS(STATIC_610), i13, i161) | >(i161, 0)
608_0_test_Load(EOS(STATIC_608), i13) → 612_0_test_Store(EOS(STATIC_612), i13, i13)
610_0_test_Inc(EOS(STATIC_610), i13, i161) → 614_0_test_JMP(EOS(STATIC_614), i13, +(i161, -1)) | >(i161, 0)
612_0_test_Store(EOS(STATIC_612), i13, i13) → 617_0_test_Load(EOS(STATIC_617), i13, i13)
614_0_test_JMP(EOS(STATIC_614), i13, i163) → 621_0_test_Load(EOS(STATIC_621), i13, i163)
617_0_test_Load(EOS(STATIC_617), i13, i13) → 637_0_test_Load(EOS(STATIC_637), i13, i13)
621_0_test_Load(EOS(STATIC_621), i13, i163) → 598_0_test_Load(EOS(STATIC_598), i13, i163)
637_0_test_Load(EOS(STATIC_637), i13, i169) → 641_0_test_LE(EOS(STATIC_641), i13, i169, i169)
641_0_test_LE(EOS(STATIC_641), i13, matching1, matching2) → 643_0_test_LE(EOS(STATIC_643), i13, 0, 0) | &&(=(matching1, 0), =(matching2, 0))
641_0_test_LE(EOS(STATIC_641), i13, i173, i173) → 645_0_test_LE(EOS(STATIC_645), i13, i173, i173)
643_0_test_LE(EOS(STATIC_643), i13, matching1, matching2) → 647_0_test_Load(EOS(STATIC_647), i13) | &&(&&(<=(0, 0), =(matching1, 0)), =(matching2, 0))
645_0_test_LE(EOS(STATIC_645), i13, i173, i173) → 649_0_test_Inc(EOS(STATIC_649), i13, i173) | >(i173, 0)
647_0_test_Load(EOS(STATIC_647), i13) → 651_0_test_Store(EOS(STATIC_651), i13, i13)
649_0_test_Inc(EOS(STATIC_649), i13, i173) → 654_0_test_JMP(EOS(STATIC_654), i13, +(i173, -1)) | >(i173, 0)
651_0_test_Store(EOS(STATIC_651), i13, i13) → 656_0_test_Load(EOS(STATIC_656), i13, i13)
654_0_test_JMP(EOS(STATIC_654), i13, i177) → 660_0_test_Load(EOS(STATIC_660), i13, i177)
656_0_test_Load(EOS(STATIC_656), i13, i13) → 676_0_test_Load(EOS(STATIC_676), i13, i13)
660_0_test_Load(EOS(STATIC_660), i13, i177) → 637_0_test_Load(EOS(STATIC_637), i13, i177)
676_0_test_Load(EOS(STATIC_676), i13, i184) → 680_0_test_LE(EOS(STATIC_680), i13, i184, i184)
680_0_test_LE(EOS(STATIC_680), i13, matching1, matching2) → 682_0_test_LE(EOS(STATIC_682), i13, 0, 0) | &&(=(matching1, 0), =(matching2, 0))
680_0_test_LE(EOS(STATIC_680), i13, i189, i189) → 683_0_test_LE(EOS(STATIC_683), i13, i189, i189)
682_0_test_LE(EOS(STATIC_682), i13, matching1, matching2) → 686_0_test_Load(EOS(STATIC_686), i13) | &&(&&(<=(0, 0), =(matching1, 0)), =(matching2, 0))
683_0_test_LE(EOS(STATIC_683), i13, i189, i189) → 688_0_test_Inc(EOS(STATIC_688), i13, i189) | >(i189, 0)
686_0_test_Load(EOS(STATIC_686), i13) → 690_0_test_Store(EOS(STATIC_690), i13, i13)
688_0_test_Inc(EOS(STATIC_688), i13, i189) → 692_0_test_JMP(EOS(STATIC_692), i13, +(i189, -1)) | >(i189, 0)
690_0_test_Store(EOS(STATIC_690), i13, i13) → 695_0_test_Load(EOS(STATIC_695), i13, i13)
692_0_test_JMP(EOS(STATIC_692), i13, i191) → 699_0_test_Load(EOS(STATIC_699), i13, i191)
695_0_test_Load(EOS(STATIC_695), i13, i13) → 713_0_test_Load(EOS(STATIC_713), i13, i13)
699_0_test_Load(EOS(STATIC_699), i13, i191) → 676_0_test_Load(EOS(STATIC_676), i13, i191)
713_0_test_Load(EOS(STATIC_713), i13, i194) → 715_0_test_LE(EOS(STATIC_715), i13, i194, i194)
715_0_test_LE(EOS(STATIC_715), i13, matching1, matching2) → 717_0_test_LE(EOS(STATIC_717), i13, 0, 0) | &&(=(matching1, 0), =(matching2, 0))
715_0_test_LE(EOS(STATIC_715), i13, i197, i197) → 718_0_test_LE(EOS(STATIC_718), i13, i197, i197)
717_0_test_LE(EOS(STATIC_717), i13, matching1, matching2) → 720_0_test_Load(EOS(STATIC_720), i13) | &&(&&(<=(0, 0), =(matching1, 0)), =(matching2, 0))
718_0_test_LE(EOS(STATIC_718), i13, i197, i197) → 722_0_test_Inc(EOS(STATIC_722), i13, i197) | >(i197, 0)
720_0_test_Load(EOS(STATIC_720), i13) → 724_0_test_Store(EOS(STATIC_724), i13)
722_0_test_Inc(EOS(STATIC_722), i13, i197) → 726_0_test_JMP(EOS(STATIC_726), i13, +(i197, -1)) | >(i197, 0)
724_0_test_Store(EOS(STATIC_724), i13) → 728_0_test_Load(EOS(STATIC_728), i13)
726_0_test_JMP(EOS(STATIC_726), i13, i199) → 731_0_test_Load(EOS(STATIC_731), i13, i199)
728_0_test_Load(EOS(STATIC_728), i13) → 744_0_test_Load(EOS(STATIC_744), i13)
731_0_test_Load(EOS(STATIC_731), i13, i199) → 713_0_test_Load(EOS(STATIC_713), i13, i199)
744_0_test_Load(EOS(STATIC_744), i203) → 746_0_test_LE(EOS(STATIC_746), i203, i203)
746_0_test_LE(EOS(STATIC_746), matching1, matching2) → 748_0_test_LE(EOS(STATIC_748), 0, 0) | &&(=(matching1, 0), =(matching2, 0))
746_0_test_LE(EOS(STATIC_746), i208, i208) → 750_0_test_LE(EOS(STATIC_750), i208, i208)
748_0_test_LE(EOS(STATIC_748), matching1, matching2) → 751_0_test_Return(EOS(STATIC_751)) | &&(&&(<=(0, 0), =(matching1, 0)), =(matching2, 0))
750_0_test_LE(EOS(STATIC_750), i208, i208) → 753_0_test_Inc(EOS(STATIC_753), i208) | >(i208, 0)
753_0_test_Inc(EOS(STATIC_753), i208) → 759_0_test_JMP(EOS(STATIC_759), +(i208, -1)) | >(i208, 0)
759_0_test_JMP(EOS(STATIC_759), i211) → 770_0_test_Load(EOS(STATIC_770), i211)
770_0_test_Load(EOS(STATIC_770), i211) → 744_0_test_Load(EOS(STATIC_744), i211)

Combined rules. Obtained 3 conditional rules for P and 25 conditional rules for R.

P rules:
90_0_main_GE(EOS(STATIC_90), x0, x1, x1, 100) → 97_1_main_InvokeMethod(97_0_test_Load(EOS(STATIC_97), x1), x0, x1, x1) | <(x1, 100)
97_1_main_InvokeMethod(751_0_test_Return(EOS(STATIC_751)), x0, x1, x1) → 90_0_main_GE(EOS(STATIC_90), x0, +(x1, 1), +(x1, 1), 100) | >(x1, 0)
90_0_main_GE(EOS(STATIC_90), x0, x1, x1, 100) → 90_0_main_GE(EOS(STATIC_90), -(x0, 1), -(x0, 1), -(x0, 1), 100) | &&(>(+(x1, 1), 100), >(x0, 1))
R rules:
97_0_test_Load(EOS(STATIC_97), x0) → 356_0_test_LE(EOS(STATIC_356), x0, x0, x0)
356_0_test_LE(EOS(STATIC_356), x0, x1, x1) → 356_0_test_LE(EOS(STATIC_356), x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
356_0_test_LE(EOS(STATIC_356), x0, 0, 0) → 389_0_test_LE(EOS(STATIC_389), x0, x0, x0)
389_0_test_LE(EOS(STATIC_389), x0, x1, x1) → 389_0_test_LE(EOS(STATIC_389), x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
389_0_test_LE(EOS(STATIC_389), x0, 0, 0) → 416_0_test_LE(EOS(STATIC_416), x0, x0, x0)
416_0_test_LE(EOS(STATIC_416), x0, x1, x1) → 416_0_test_LE(EOS(STATIC_416), x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
416_0_test_LE(EOS(STATIC_416), x0, 0, 0) → 456_0_test_LE(EOS(STATIC_456), x0, x0, x0)
456_0_test_LE(EOS(STATIC_456), x0, x1, x1) → 456_0_test_LE(EOS(STATIC_456), x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
456_0_test_LE(EOS(STATIC_456), x0, 0, 0) → 496_0_test_LE(EOS(STATIC_496), x0, x0, x0)
496_0_test_LE(EOS(STATIC_496), x0, x1, x1) → 496_0_test_LE(EOS(STATIC_496), x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
496_0_test_LE(EOS(STATIC_496), x0, 0, 0) → 528_0_test_LE(EOS(STATIC_528), x0, x0, x0)
528_0_test_LE(EOS(STATIC_528), x0, x1, x1) → 528_0_test_LE(EOS(STATIC_528), x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
528_0_test_LE(EOS(STATIC_528), x0, 0, 0) → 564_0_test_LE(EOS(STATIC_564), x0, x0, x0)
564_0_test_LE(EOS(STATIC_564), x0, x1, x1) → 564_0_test_LE(EOS(STATIC_564), x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
564_0_test_LE(EOS(STATIC_564), x0, 0, 0) → 602_0_test_LE(EOS(STATIC_602), x0, x0, x0)
602_0_test_LE(EOS(STATIC_602), x0, x1, x1) → 602_0_test_LE(EOS(STATIC_602), x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
602_0_test_LE(EOS(STATIC_602), x0, 0, 0) → 641_0_test_LE(EOS(STATIC_641), x0, x0, x0)
641_0_test_LE(EOS(STATIC_641), x0, x1, x1) → 641_0_test_LE(EOS(STATIC_641), x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
641_0_test_LE(EOS(STATIC_641), x0, 0, 0) → 680_0_test_LE(EOS(STATIC_680), x0, x0, x0)
680_0_test_LE(EOS(STATIC_680), x0, x1, x1) → 680_0_test_LE(EOS(STATIC_680), x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
680_0_test_LE(EOS(STATIC_680), x0, 0, 0) → 715_0_test_LE(EOS(STATIC_715), x0, x0, x0)
715_0_test_LE(EOS(STATIC_715), x0, x1, x1) → 715_0_test_LE(EOS(STATIC_715), x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
715_0_test_LE(EOS(STATIC_715), x0, 0, 0) → 746_0_test_LE(EOS(STATIC_746), x0, x0)
746_0_test_LE(EOS(STATIC_746), 0, 0) → 751_0_test_Return(EOS(STATIC_751))
746_0_test_LE(EOS(STATIC_746), x0, x0) → 746_0_test_LE(EOS(STATIC_746), +(x0, -1), +(x0, -1)) | >(x0, 0)

Filtered ground terms:

90_0_main_GE(x1, x2, x3, x4, x5) → 90_0_main_GE(x2, x3, x4)
Cond_90_0_main_GE1(x1, x2, x3, x4, x5, x6) → Cond_90_0_main_GE1(x1, x3, x4, x5)
Cond_97_1_main_InvokeMethod(x1, x2, x3, x4, x5) → Cond_97_1_main_InvokeMethod(x1, x3, x4, x5)
751_0_test_Return(x1) → 751_0_test_Return
97_0_test_Load(x1, x2) → 97_0_test_Load(x2)
Cond_90_0_main_GE(x1, x2, x3, x4, x5, x6) → Cond_90_0_main_GE(x1, x3, x4, x5)
746_0_test_LE(x1, x2, x3) → 746_0_test_LE(x2, x3)
Cond_746_0_test_LE(x1, x2, x3, x4) → Cond_746_0_test_LE(x1, x3, x4)
715_0_test_LE(x1, x2, x3, x4) → 715_0_test_LE(x2, x3, x4)
Cond_715_0_test_LE(x1, x2, x3, x4, x5) → Cond_715_0_test_LE(x1, x3, x4, x5)
680_0_test_LE(x1, x2, x3, x4) → 680_0_test_LE(x2, x3, x4)
Cond_680_0_test_LE(x1, x2, x3, x4, x5) → Cond_680_0_test_LE(x1, x3, x4, x5)
641_0_test_LE(x1, x2, x3, x4) → 641_0_test_LE(x2, x3, x4)
Cond_641_0_test_LE(x1, x2, x3, x4, x5) → Cond_641_0_test_LE(x1, x3, x4, x5)
602_0_test_LE(x1, x2, x3, x4) → 602_0_test_LE(x2, x3, x4)
Cond_602_0_test_LE(x1, x2, x3, x4, x5) → Cond_602_0_test_LE(x1, x3, x4, x5)
564_0_test_LE(x1, x2, x3, x4) → 564_0_test_LE(x2, x3, x4)
Cond_564_0_test_LE(x1, x2, x3, x4, x5) → Cond_564_0_test_LE(x1, x3, x4, x5)
528_0_test_LE(x1, x2, x3, x4) → 528_0_test_LE(x2, x3, x4)
Cond_528_0_test_LE(x1, x2, x3, x4, x5) → Cond_528_0_test_LE(x1, x3, x4, x5)
496_0_test_LE(x1, x2, x3, x4) → 496_0_test_LE(x2, x3, x4)
Cond_496_0_test_LE(x1, x2, x3, x4, x5) → Cond_496_0_test_LE(x1, x3, x4, x5)
456_0_test_LE(x1, x2, x3, x4) → 456_0_test_LE(x2, x3, x4)
Cond_456_0_test_LE(x1, x2, x3, x4, x5) → Cond_456_0_test_LE(x1, x3, x4, x5)
416_0_test_LE(x1, x2, x3, x4) → 416_0_test_LE(x2, x3, x4)
Cond_416_0_test_LE(x1, x2, x3, x4, x5) → Cond_416_0_test_LE(x1, x3, x4, x5)
389_0_test_LE(x1, x2, x3, x4) → 389_0_test_LE(x2, x3, x4)
Cond_389_0_test_LE(x1, x2, x3, x4, x5) → Cond_389_0_test_LE(x1, x3, x4, x5)
356_0_test_LE(x1, x2, x3, x4) → 356_0_test_LE(x2, x3, x4)
Cond_356_0_test_LE(x1, x2, x3, x4, x5) → Cond_356_0_test_LE(x1, x3, x4, x5)

Filtered duplicate args:

90_0_main_GE(x1, x2, x3) → 90_0_main_GE(x1, x3)
Cond_90_0_main_GE(x1, x2, x3, x4) → Cond_90_0_main_GE(x1, x2, x4)
97_1_main_InvokeMethod(x1, x2, x3, x4) → 97_1_main_InvokeMethod(x1, x2, x4)
Cond_97_1_main_InvokeMethod(x1, x2, x3, x4) → Cond_97_1_main_InvokeMethod(x1, x2, x4)
Cond_90_0_main_GE1(x1, x2, x3, x4) → Cond_90_0_main_GE1(x1, x2, x4)
Cond_356_0_test_LE(x1, x2, x3, x4) → Cond_356_0_test_LE(x1, x2, x4)
Cond_389_0_test_LE(x1, x2, x3, x4) → Cond_389_0_test_LE(x1, x2, x4)
Cond_416_0_test_LE(x1, x2, x3, x4) → Cond_416_0_test_LE(x1, x2, x4)
Cond_456_0_test_LE(x1, x2, x3, x4) → Cond_456_0_test_LE(x1, x2, x4)
Cond_496_0_test_LE(x1, x2, x3, x4) → Cond_496_0_test_LE(x1, x2, x4)
Cond_528_0_test_LE(x1, x2, x3, x4) → Cond_528_0_test_LE(x1, x2, x4)
Cond_564_0_test_LE(x1, x2, x3, x4) → Cond_564_0_test_LE(x1, x2, x4)
Cond_602_0_test_LE(x1, x2, x3, x4) → Cond_602_0_test_LE(x1, x2, x4)
Cond_641_0_test_LE(x1, x2, x3, x4) → Cond_641_0_test_LE(x1, x2, x4)
Cond_680_0_test_LE(x1, x2, x3, x4) → Cond_680_0_test_LE(x1, x2, x4)
Cond_715_0_test_LE(x1, x2, x3, x4) → Cond_715_0_test_LE(x1, x2, x4)
746_0_test_LE(x1, x2) → 746_0_test_LE(x2)
Cond_746_0_test_LE(x1, x2, x3) → Cond_746_0_test_LE(x1, x3)

Filtered unneeded arguments:

Cond_90_0_main_GE1(x1, x2, x3) → Cond_90_0_main_GE1(x1, x2)

Combined rules. Obtained 3 conditional rules for P and 25 conditional rules for R.

P rules:
90_0_main_GE(x0, x1) → 97_1_main_InvokeMethod(97_0_test_Load(x1), x0, x1) | <(x1, 100)
97_1_main_InvokeMethod(751_0_test_Return, x0, x1) → 90_0_main_GE(x0, +(x1, 1)) | >(x1, 0)
90_0_main_GE(x0, x1) → 90_0_main_GE(-(x0, 1), -(x0, 1)) | &&(>(x1, 99), >(x0, 1))
R rules:
97_0_test_Load(x0) → 356_0_test_LE(x0, x0, x0)
356_0_test_LE(x0, x1, x1) → 356_0_test_LE(x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
356_0_test_LE(x0, 0, 0) → 389_0_test_LE(x0, x0, x0)
389_0_test_LE(x0, x1, x1) → 389_0_test_LE(x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
389_0_test_LE(x0, 0, 0) → 416_0_test_LE(x0, x0, x0)
416_0_test_LE(x0, x1, x1) → 416_0_test_LE(x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
416_0_test_LE(x0, 0, 0) → 456_0_test_LE(x0, x0, x0)
456_0_test_LE(x0, x1, x1) → 456_0_test_LE(x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
456_0_test_LE(x0, 0, 0) → 496_0_test_LE(x0, x0, x0)
496_0_test_LE(x0, x1, x1) → 496_0_test_LE(x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
496_0_test_LE(x0, 0, 0) → 528_0_test_LE(x0, x0, x0)
528_0_test_LE(x0, x1, x1) → 528_0_test_LE(x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
528_0_test_LE(x0, 0, 0) → 564_0_test_LE(x0, x0, x0)
564_0_test_LE(x0, x1, x1) → 564_0_test_LE(x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
564_0_test_LE(x0, 0, 0) → 602_0_test_LE(x0, x0, x0)
602_0_test_LE(x0, x1, x1) → 602_0_test_LE(x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
602_0_test_LE(x0, 0, 0) → 641_0_test_LE(x0, x0, x0)
641_0_test_LE(x0, x1, x1) → 641_0_test_LE(x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
641_0_test_LE(x0, 0, 0) → 680_0_test_LE(x0, x0, x0)
680_0_test_LE(x0, x1, x1) → 680_0_test_LE(x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
680_0_test_LE(x0, 0, 0) → 715_0_test_LE(x0, x0, x0)
715_0_test_LE(x0, x1, x1) → 715_0_test_LE(x0, +(x1, -1), +(x1, -1)) | >(x1, 0)
715_0_test_LE(x0, 0, 0) → 746_0_test_LE(x0)
746_0_test_LE(0) → 751_0_test_Return
746_0_test_LE(x0) → 746_0_test_LE(+(x0, -1)) | >(x0, 0)

Finished conversion. Obtained 6 rules for P and 37 rules for R. System has predefined symbols.

P rules:
90_0_MAIN_GE(x0, x1) → COND_90_0_MAIN_GE(<(x1, 100), x0, x1)
COND_90_0_MAIN_GE(TRUE, x0, x1) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1), x0, x1)
97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0, x1) → COND_97_1_MAIN_INVOKEMETHOD(>(x1, 0), 751_0_test_Return, x0, x1)
COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0, x1) → 90_0_MAIN_GE(x0, +(x1, 1))
90_0_MAIN_GE(x0, x1) → COND_90_0_MAIN_GE1(&&(>(x1, 99), >(x0, 1)), x0, x1)
COND_90_0_MAIN_GE1(TRUE, x0, x1) → 90_0_MAIN_GE(-(x0, 1), -(x0, 1))
R rules:
97_0_test_Load(x0) → 356_0_test_LE(x0, x0, x0)
356_0_test_LE(x0, x1, x1) → Cond_356_0_test_LE(>(x1, 0), x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1) → 356_0_test_LE(x0, +(x1, -1), +(x1, -1))
356_0_test_LE(x0, 0, 0) → 389_0_test_LE(x0, x0, x0)
389_0_test_LE(x0, x1, x1) → Cond_389_0_test_LE(>(x1, 0), x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1) → 389_0_test_LE(x0, +(x1, -1), +(x1, -1))
389_0_test_LE(x0, 0, 0) → 416_0_test_LE(x0, x0, x0)
416_0_test_LE(x0, x1, x1) → Cond_416_0_test_LE(>(x1, 0), x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1) → 416_0_test_LE(x0, +(x1, -1), +(x1, -1))
416_0_test_LE(x0, 0, 0) → 456_0_test_LE(x0, x0, x0)
456_0_test_LE(x0, x1, x1) → Cond_456_0_test_LE(>(x1, 0), x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1) → 456_0_test_LE(x0, +(x1, -1), +(x1, -1))
456_0_test_LE(x0, 0, 0) → 496_0_test_LE(x0, x0, x0)
496_0_test_LE(x0, x1, x1) → Cond_496_0_test_LE(>(x1, 0), x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1) → 496_0_test_LE(x0, +(x1, -1), +(x1, -1))
496_0_test_LE(x0, 0, 0) → 528_0_test_LE(x0, x0, x0)
528_0_test_LE(x0, x1, x1) → Cond_528_0_test_LE(>(x1, 0), x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1) → 528_0_test_LE(x0, +(x1, -1), +(x1, -1))
528_0_test_LE(x0, 0, 0) → 564_0_test_LE(x0, x0, x0)
564_0_test_LE(x0, x1, x1) → Cond_564_0_test_LE(>(x1, 0), x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1) → 564_0_test_LE(x0, +(x1, -1), +(x1, -1))
564_0_test_LE(x0, 0, 0) → 602_0_test_LE(x0, x0, x0)
602_0_test_LE(x0, x1, x1) → Cond_602_0_test_LE(>(x1, 0), x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1) → 602_0_test_LE(x0, +(x1, -1), +(x1, -1))
602_0_test_LE(x0, 0, 0) → 641_0_test_LE(x0, x0, x0)
641_0_test_LE(x0, x1, x1) → Cond_641_0_test_LE(>(x1, 0), x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1) → 641_0_test_LE(x0, +(x1, -1), +(x1, -1))
641_0_test_LE(x0, 0, 0) → 680_0_test_LE(x0, x0, x0)
680_0_test_LE(x0, x1, x1) → Cond_680_0_test_LE(>(x1, 0), x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1) → 680_0_test_LE(x0, +(x1, -1), +(x1, -1))
680_0_test_LE(x0, 0, 0) → 715_0_test_LE(x0, x0, x0)
715_0_test_LE(x0, x1, x1) → Cond_715_0_test_LE(>(x1, 0), x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1) → 715_0_test_LE(x0, +(x1, -1), +(x1, -1))
715_0_test_LE(x0, 0, 0) → 746_0_test_LE(x0)
746_0_test_LE(0) → 751_0_test_Return
746_0_test_LE(x0) → Cond_746_0_test_LE(>(x0, 0), x0)
Cond_746_0_test_LE(TRUE, x0) → 746_0_test_LE(+(x0, -1))

(139) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer, Boolean

The ITRS R consists of the following rules:
97_0_test_Load(x0) → 356_0_test_LE(x0, x0, x0)
356_0_test_LE(x0, x1, x1) → Cond_356_0_test_LE(x1 > 0, x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1) → 356_0_test_LE(x0, x1 + -1, x1 + -1)
356_0_test_LE(x0, 0, 0) → 389_0_test_LE(x0, x0, x0)
389_0_test_LE(x0, x1, x1) → Cond_389_0_test_LE(x1 > 0, x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1) → 389_0_test_LE(x0, x1 + -1, x1 + -1)
389_0_test_LE(x0, 0, 0) → 416_0_test_LE(x0, x0, x0)
416_0_test_LE(x0, x1, x1) → Cond_416_0_test_LE(x1 > 0, x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1) → 416_0_test_LE(x0, x1 + -1, x1 + -1)
416_0_test_LE(x0, 0, 0) → 456_0_test_LE(x0, x0, x0)
456_0_test_LE(x0, x1, x1) → Cond_456_0_test_LE(x1 > 0, x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1) → 456_0_test_LE(x0, x1 + -1, x1 + -1)
456_0_test_LE(x0, 0, 0) → 496_0_test_LE(x0, x0, x0)
496_0_test_LE(x0, x1, x1) → Cond_496_0_test_LE(x1 > 0, x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1) → 496_0_test_LE(x0, x1 + -1, x1 + -1)
496_0_test_LE(x0, 0, 0) → 528_0_test_LE(x0, x0, x0)
528_0_test_LE(x0, x1, x1) → Cond_528_0_test_LE(x1 > 0, x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1) → 528_0_test_LE(x0, x1 + -1, x1 + -1)
528_0_test_LE(x0, 0, 0) → 564_0_test_LE(x0, x0, x0)
564_0_test_LE(x0, x1, x1) → Cond_564_0_test_LE(x1 > 0, x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1) → 564_0_test_LE(x0, x1 + -1, x1 + -1)
564_0_test_LE(x0, 0, 0) → 602_0_test_LE(x0, x0, x0)
602_0_test_LE(x0, x1, x1) → Cond_602_0_test_LE(x1 > 0, x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1) → 602_0_test_LE(x0, x1 + -1, x1 + -1)
602_0_test_LE(x0, 0, 0) → 641_0_test_LE(x0, x0, x0)
641_0_test_LE(x0, x1, x1) → Cond_641_0_test_LE(x1 > 0, x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1) → 641_0_test_LE(x0, x1 + -1, x1 + -1)
641_0_test_LE(x0, 0, 0) → 680_0_test_LE(x0, x0, x0)
680_0_test_LE(x0, x1, x1) → Cond_680_0_test_LE(x1 > 0, x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1) → 680_0_test_LE(x0, x1 + -1, x1 + -1)
680_0_test_LE(x0, 0, 0) → 715_0_test_LE(x0, x0, x0)
715_0_test_LE(x0, x1, x1) → Cond_715_0_test_LE(x1 > 0, x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1) → 715_0_test_LE(x0, x1 + -1, x1 + -1)
715_0_test_LE(x0, 0, 0) → 746_0_test_LE(x0)
746_0_test_LE(0) → 751_0_test_Return
746_0_test_LE(x0) → Cond_746_0_test_LE(x0 > 0, x0)
Cond_746_0_test_LE(TRUE, x0) → 746_0_test_LE(x0 + -1)

The integer pair graph contains the following rules and edges:
(0): 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(x1[0] < 100, x0[0], x1[0])
(1): COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])
(2): 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(x1[2] > 0, 751_0_test_Return, x0[2], x1[2])
(3): COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], x1[3] + 1)
(4): 90_0_MAIN_GE(x0[4], x1[4]) → COND_90_0_MAIN_GE1(x1[4] > 99 && x0[4] > 1, x0[4], x1[4])
(5): COND_90_0_MAIN_GE1(TRUE, x0[5], x1[5]) → 90_0_MAIN_GE(x0[5] - 1, x0[5] - 1)

(0) -> (1), if (x1[0] < 100 ∧x0[0] →^* x0[1]∧x1[0] →^* x1[1])

(1) -> (2), if (97_0_test_Load(x1[1]) →^* 751_0_test_Return∧x0[1] →^* x0[2]∧x1[1] →^* x1[2])

(2) -> (3), if (x1[2] > 0 ∧x0[2] →^* x0[3]∧x1[2] →^* x1[3])

(3) -> (0), if (x0[3] →^* x0[0]∧x1[3] + 1 →^* x1[0])

(3) -> (4), if (x0[3] →^* x0[4]∧x1[3] + 1 →^* x1[4])

(4) -> (5), if (x1[4] > 99 && x0[4] > 1 ∧x0[4] →^* x0[5]∧x1[4] →^* x1[5])

(5) -> (0), if (x0[5] - 1 →^* x0[0]∧x0[5] - 1 →^* x1[0])

(5) -> (4), if (x0[5] - 1 →^* x0[4]∧x0[5] - 1 →^* x1[4])

The set Q consists of the following terms:
97_0_test_Load(x0)
356_0_test_LE(x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1)
389_0_test_LE(x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1)
416_0_test_LE(x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1)
456_0_test_LE(x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1)
496_0_test_LE(x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1)
528_0_test_LE(x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1)
564_0_test_LE(x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1)
602_0_test_LE(x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1)
641_0_test_LE(x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1)
680_0_test_LE(x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1)
715_0_test_LE(x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1)
746_0_test_LE(x0)
Cond_746_0_test_LE(TRUE, x0)

(140) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair 90_0_MAIN_GE(x0, x1) → COND_90_0_MAIN_GE(<(x1, 100), x0, x1) the following chains were created:

• We consider the chain 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0]), COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1]) which results in the following constraint:
  

  (1)    (<(x1[0], 100)=TRUE∧x0[0]=x0[1]∧x1[0]=x1[1] ⇒ 90_0_MAIN_GE(x0[0], x1[0])≥NonInfC∧90_0_MAIN_GE(x0[0], x1[0])≥COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])∧(U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥))

  
  
  We simplified constraint (1) using rule (IV) which results in the following new constraint:
  

  (2)    (<(x1[0], 100)=TRUE ⇒ 90_0_MAIN_GE(x0[0], x1[0])≥NonInfC∧90_0_MAIN_GE(x0[0], x1[0])≥COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])∧(U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥))

  
  
  We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (3)    ([99] + [-1]x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_87 + (-1)Bound*bni_87] + [bni_87]x0[0] ≥ 0∧[(-1)bso_88] ≥ 0)

  
  
  We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (4)    ([99] + [-1]x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_87 + (-1)Bound*bni_87] + [bni_87]x0[0] ≥ 0∧[(-1)bso_88] ≥ 0)

  
  
  We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (5)    ([99] + [-1]x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_87 + (-1)Bound*bni_87] + [bni_87]x0[0] ≥ 0∧[(-1)bso_88] ≥ 0)

  
  
  We simplified constraint (5) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (6)    ([99] + [-1]x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[bni_87] = 0∧[(-1)bni_87 + (-1)Bound*bni_87] ≥ 0∧0 = 0∧[(-1)bso_88] ≥ 0)

  
  
  We simplified constraint (6) using rule (IDP_SMT_SPLIT) which results in the following new constraints:
  

  (7)    ([99] + [-1]x1[0] ≥ 0∧x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[bni_87] = 0∧[(-1)bni_87 + (-1)Bound*bni_87] ≥ 0∧0 = 0∧[(-1)bso_88] ≥ 0)

  
  

  (8)    ([99] + x1[0] ≥ 0∧x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[bni_87] = 0∧[(-1)bni_87 + (-1)Bound*bni_87] ≥ 0∧0 = 0∧[(-1)bso_88] ≥ 0)

  
  
  

For Pair COND_90_0_MAIN_GE(TRUE, x0, x1) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1), x0, x1) the following chains were created:

• We consider the chain COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1]) which results in the following constraint:
  

  (9)    (COND_90_0_MAIN_GE(TRUE, x0[1], x1[1])≥NonInfC∧COND_90_0_MAIN_GE(TRUE, x0[1], x1[1])≥97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])∧(U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥))

  
  
  We simplified constraint (9) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (10)    ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_89] = 0∧[(-1)bso_90] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (11)    ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_89] = 0∧[(-1)bso_90] ≥ 0)

  
  
  We simplified constraint (11) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (12)    ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_89] = 0∧[(-1)bso_90] ≥ 0)

  
  
  We simplified constraint (12) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (13)    ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_89] = 0∧0 = 0∧0 = 0∧[(-1)bso_90] ≥ 0)

  
  
  

For Pair 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0, x1) → COND_97_1_MAIN_INVOKEMETHOD(>(x1, 0), 751_0_test_Return, x0, x1) the following chains were created:

• We consider the chain 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2]), COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1)) which results in the following constraint:
  

  (14)    (>(x1[2], 0)=TRUE∧x0[2]=x0[3]∧x1[2]=x1[3] ⇒ 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2])≥NonInfC∧97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2])≥COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])∧(U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥))

  
  
  We simplified constraint (14) using rule (IV) which results in the following new constraint:
  

  (15)    (>(x1[2], 0)=TRUE ⇒ 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2])≥NonInfC∧97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2])≥COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])∧(U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥))

  
  
  We simplified constraint (15) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (16)    (x1[2] + [-1] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-1)bni_91 + (-1)Bound*bni_91] + [bni_91]x0[2] ≥ 0∧[(-1)bso_92] ≥ 0)

  
  
  We simplified constraint (16) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (17)    (x1[2] + [-1] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-1)bni_91 + (-1)Bound*bni_91] + [bni_91]x0[2] ≥ 0∧[(-1)bso_92] ≥ 0)

  
  
  We simplified constraint (17) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (18)    (x1[2] + [-1] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-1)bni_91 + (-1)Bound*bni_91] + [bni_91]x0[2] ≥ 0∧[(-1)bso_92] ≥ 0)

  
  
  We simplified constraint (18) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (19)    (x1[2] + [-1] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[bni_91] = 0∧[(-1)bni_91 + (-1)Bound*bni_91] ≥ 0∧0 = 0∧[(-1)bso_92] ≥ 0)

  
  
  We simplified constraint (19) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (20)    (x1[2] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[bni_91] = 0∧[(-1)bni_91 + (-1)Bound*bni_91] ≥ 0∧0 = 0∧[(-1)bso_92] ≥ 0)

  
  
  

For Pair COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0, x1) → 90_0_MAIN_GE(x0, +(x1, 1)) the following chains were created:

• We consider the chain COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1)) which results in the following constraint:
  

  (21)    (COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3])≥NonInfC∧COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3])≥90_0_MAIN_GE(x0[3], +(x1[3], 1))∧(U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥))

  
  
  We simplified constraint (21) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (22)    ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_93] = 0∧[(-1)bso_94] ≥ 0)

  
  
  We simplified constraint (22) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (23)    ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_93] = 0∧[(-1)bso_94] ≥ 0)

  
  
  We simplified constraint (23) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (24)    ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_93] = 0∧[(-1)bso_94] ≥ 0)

  
  
  We simplified constraint (24) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (25)    ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_93] = 0∧0 = 0∧0 = 0∧[(-1)bso_94] ≥ 0)

  
  
  

For Pair 90_0_MAIN_GE(x0, x1) → COND_90_0_MAIN_GE1(&&(>(x1, 99), >(x0, 1)), x0, x1) the following chains were created:

• We consider the chain 90_0_MAIN_GE(x0[4], x1[4]) → COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4]), COND_90_0_MAIN_GE1(TRUE, x0[5], x1[5]) → 90_0_MAIN_GE(-(x0[5], 1), -(x0[5], 1)) which results in the following constraint:
  

  (26)    (&&(>(x1[4], 99), >(x0[4], 1))=TRUE∧x0[4]=x0[5]∧x1[4]=x1[5] ⇒ 90_0_MAIN_GE(x0[4], x1[4])≥NonInfC∧90_0_MAIN_GE(x0[4], x1[4])≥COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4])∧(U^Increasing(COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4])), ≥))

  
  
  We simplified constraint (26) using rules (IV), (IDP_BOOLEAN) which results in the following new constraint:
  

  (27)    (>(x1[4], 99)=TRUE∧>(x0[4], 1)=TRUE ⇒ 90_0_MAIN_GE(x0[4], x1[4])≥NonInfC∧90_0_MAIN_GE(x0[4], x1[4])≥COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4])∧(U^Increasing(COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4])), ≥))

  
  
  We simplified constraint (27) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (28)    (x1[4] + [-100] ≥ 0∧x0[4] + [-2] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4])), ≥)∧[(-1)bni_95 + (-1)Bound*bni_95] + [bni_95]x0[4] ≥ 0∧[(-1)bso_96] ≥ 0)

  
  
  We simplified constraint (28) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (29)    (x1[4] + [-100] ≥ 0∧x0[4] + [-2] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4])), ≥)∧[(-1)bni_95 + (-1)Bound*bni_95] + [bni_95]x0[4] ≥ 0∧[(-1)bso_96] ≥ 0)

  
  
  We simplified constraint (29) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (30)    (x1[4] + [-100] ≥ 0∧x0[4] + [-2] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4])), ≥)∧[(-1)bni_95 + (-1)Bound*bni_95] + [bni_95]x0[4] ≥ 0∧[(-1)bso_96] ≥ 0)

  
  
  We simplified constraint (30) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (31)    (x1[4] ≥ 0∧x0[4] + [-2] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4])), ≥)∧[(-1)bni_95 + (-1)Bound*bni_95] + [bni_95]x0[4] ≥ 0∧[(-1)bso_96] ≥ 0)

  
  
  We simplified constraint (31) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (32)    (x1[4] ≥ 0∧x0[4] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4])), ≥)∧[bni_95 + (-1)Bound*bni_95] + [bni_95]x0[4] ≥ 0∧[(-1)bso_96] ≥ 0)

  
  
  

For Pair COND_90_0_MAIN_GE1(TRUE, x0, x1) → 90_0_MAIN_GE(-(x0, 1), -(x0, 1)) the following chains were created:

• We consider the chain COND_90_0_MAIN_GE1(TRUE, x0[5], x1[5]) → 90_0_MAIN_GE(-(x0[5], 1), -(x0[5], 1)) which results in the following constraint:
  

  (33)    (COND_90_0_MAIN_GE1(TRUE, x0[5], x1[5])≥NonInfC∧COND_90_0_MAIN_GE1(TRUE, x0[5], x1[5])≥90_0_MAIN_GE(-(x0[5], 1), -(x0[5], 1))∧(U^Increasing(90_0_MAIN_GE(-(x0[5], 1), -(x0[5], 1))), ≥))

  
  
  We simplified constraint (33) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (34)    ((U^Increasing(90_0_MAIN_GE(-(x0[5], 1), -(x0[5], 1))), ≥)∧[bni_97] = 0∧[1 + (-1)bso_98] ≥ 0)

  
  
  We simplified constraint (34) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (35)    ((U^Increasing(90_0_MAIN_GE(-(x0[5], 1), -(x0[5], 1))), ≥)∧[bni_97] = 0∧[1 + (-1)bso_98] ≥ 0)

  
  
  We simplified constraint (35) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (36)    ((U^Increasing(90_0_MAIN_GE(-(x0[5], 1), -(x0[5], 1))), ≥)∧[bni_97] = 0∧[1 + (-1)bso_98] ≥ 0)

  
  
  We simplified constraint (36) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (37)    ((U^Increasing(90_0_MAIN_GE(-(x0[5], 1), -(x0[5], 1))), ≥)∧[bni_97] = 0∧0 = 0∧0 = 0∧[1 + (-1)bso_98] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• 90_0_MAIN_GE(x0, x1) → COND_90_0_MAIN_GE(<(x1, 100), x0, x1)
  
  • ([99] + [-1]x1[0] ≥ 0∧x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[bni_87] = 0∧[(-1)bni_87 + (-1)Bound*bni_87] ≥ 0∧0 = 0∧[(-1)bso_88] ≥ 0)
    
  • ([99] + x1[0] ≥ 0∧x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[bni_87] = 0∧[(-1)bni_87 + (-1)Bound*bni_87] ≥ 0∧0 = 0∧[(-1)bso_88] ≥ 0)
    
  
  
• COND_90_0_MAIN_GE(TRUE, x0, x1) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1), x0, x1)
  
  • ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_89] = 0∧0 = 0∧0 = 0∧[(-1)bso_90] ≥ 0)
    
  
  
• 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0, x1) → COND_97_1_MAIN_INVOKEMETHOD(>(x1, 0), 751_0_test_Return, x0, x1)
  
  • (x1[2] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[bni_91] = 0∧[(-1)bni_91 + (-1)Bound*bni_91] ≥ 0∧0 = 0∧[(-1)bso_92] ≥ 0)
    
  
  
• COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0, x1) → 90_0_MAIN_GE(x0, +(x1, 1))
  
  • ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_93] = 0∧0 = 0∧0 = 0∧[(-1)bso_94] ≥ 0)
    
  
  
• 90_0_MAIN_GE(x0, x1) → COND_90_0_MAIN_GE1(&&(>(x1, 99), >(x0, 1)), x0, x1)
  
  • (x1[4] ≥ 0∧x0[4] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4])), ≥)∧[bni_95 + (-1)Bound*bni_95] + [bni_95]x0[4] ≥ 0∧[(-1)bso_96] ≥ 0)
    
  
  
• COND_90_0_MAIN_GE1(TRUE, x0, x1) → 90_0_MAIN_GE(-(x0, 1), -(x0, 1))
  
  • ((U^Increasing(90_0_MAIN_GE(-(x0[5], 1), -(x0[5], 1))), ≥)∧[bni_97] = 0∧0 = 0∧0 = 0∧[1 + (-1)bso_98] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(97_0_test_Load(x₁)) = [1]   
POL(356_0_test_LE(x₁, x₂, x₃)) = [1] + x₃ + [-1]x₂   
POL(Cond_356_0_test_LE(x₁, x₂, x₃, x₄)) = [1] + [-1]x₄ + x₃   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   
POL(389_0_test_LE(x₁, x₂, x₃)) = [1] + x₃ + [-1]x₂   
POL(Cond_389_0_test_LE(x₁, x₂, x₃, x₄)) = [1] + [-1]x₄ + x₃   
POL(416_0_test_LE(x₁, x₂, x₃)) = [1] + x₃ + [-1]x₂   
POL(Cond_416_0_test_LE(x₁, x₂, x₃, x₄)) = [1] + [-1]x₄ + x₃   
POL(456_0_test_LE(x₁, x₂, x₃)) = [1] + x₃ + [-1]x₂   
POL(Cond_456_0_test_LE(x₁, x₂, x₃, x₄)) = [1] + [-1]x₄ + x₃   
POL(496_0_test_LE(x₁, x₂, x₃)) = [1] + x₃ + [-1]x₂   
POL(Cond_496_0_test_LE(x₁, x₂, x₃, x₄)) = [1] + [-1]x₄ + x₃   
POL(528_0_test_LE(x₁, x₂, x₃)) = [1] + x₃ + [-1]x₂   
POL(Cond_528_0_test_LE(x₁, x₂, x₃, x₄)) = [1] + [-1]x₄ + x₃   
POL(564_0_test_LE(x₁, x₂, x₃)) = [1] + x₃ + [-1]x₂   
POL(Cond_564_0_test_LE(x₁, x₂, x₃, x₄)) = [1] + [-1]x₄ + x₃   
POL(602_0_test_LE(x₁, x₂, x₃)) = [1]   
POL(Cond_602_0_test_LE(x₁, x₂, x₃, x₄)) = [1]   
POL(641_0_test_LE(x₁, x₂, x₃)) = [1] + x₃ + [-1]x₂   
POL(Cond_641_0_test_LE(x₁, x₂, x₃, x₄)) = [1] + [-1]x₄ + x₃   
POL(680_0_test_LE(x₁, x₂, x₃)) = [1] + x₃ + [-1]x₂   
POL(Cond_680_0_test_LE(x₁, x₂, x₃, x₄)) = [1] + [-1]x₄ + x₃   
POL(715_0_test_LE(x₁, x₂, x₃)) = [1] + x₃ + [-1]x₂   
POL(Cond_715_0_test_LE(x₁, x₂, x₃, x₄)) = [1] + [-1]x₄ + x₃   
POL(746_0_test_LE(x₁)) = [1]   
POL(751_0_test_Return) = [1]   
POL(Cond_746_0_test_LE(x₁, x₂)) = [1]   
POL(90_0_MAIN_GE(x₁, x₂)) = [-1] + x₁   
POL(COND_90_0_MAIN_GE(x₁, x₂, x₃)) = [-1] + x₂   
POL(<(x₁, x₂)) = [-1]   
POL(100) = [100]   
POL(97_1_MAIN_INVOKEMETHOD(x₁, x₂, x₃)) = [-1]x₁ + x₂   
POL(COND_97_1_MAIN_INVOKEMETHOD(x₁, x₂, x₃, x₄)) = [-1] + x₃   
POL(1) = [1]   
POL(COND_90_0_MAIN_GE1(x₁, x₂, x₃)) = [-1] + x₂   
POL(&&(x₁, x₂)) = [-1]   
POL(99) = [99]   
POL(-(x₁, x₂)) = x₁ + [-1]x₂   

The following pairs are in P_>:

COND_90_0_MAIN_GE1(TRUE, x0[5], x1[5]) → 90_0_MAIN_GE(-(x0[5], 1), -(x0[5], 1))

The following pairs are in P_bound:

90_0_MAIN_GE(x0[4], x1[4]) → COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4])

The following pairs are in P_≥:

90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])
COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])
97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])
COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1))
90_0_MAIN_GE(x0[4], x1[4]) → COND_90_0_MAIN_GE1(&&(>(x1[4], 99), >(x0[4], 1)), x0[4], x1[4])

At least the following rules have been oriented under context sensitive arithmetic replacement:

97_0_test_Load(x0)¹ ↔ 356_0_test_LE(x0, x0, x0)¹
356_0_test_LE(x0, 0, 0)¹ ↔ 389_0_test_LE(x0, x0, x0)¹
Cond_356_0_test_LE(TRUE, x0, x1, x1)¹ ↔ 356_0_test_LE(x0, +(x1, -1), +(x1, -1))¹
356_0_test_LE(x0, x1, x1)¹ ↔ Cond_356_0_test_LE(>(x1, 0), x0, x1, x1)¹
389_0_test_LE(x0, 0, 0)¹ ↔ 416_0_test_LE(x0, x0, x0)¹
Cond_389_0_test_LE(TRUE, x0, x1, x1)¹ ↔ 389_0_test_LE(x0, +(x1, -1), +(x1, -1))¹
389_0_test_LE(x0, x1, x1)¹ ↔ Cond_389_0_test_LE(>(x1, 0), x0, x1, x1)¹
416_0_test_LE(x0, 0, 0)¹ ↔ 456_0_test_LE(x0, x0, x0)¹
Cond_416_0_test_LE(TRUE, x0, x1, x1)¹ ↔ 416_0_test_LE(x0, +(x1, -1), +(x1, -1))¹
416_0_test_LE(x0, x1, x1)¹ ↔ Cond_416_0_test_LE(>(x1, 0), x0, x1, x1)¹
456_0_test_LE(x0, 0, 0)¹ ↔ 496_0_test_LE(x0, x0, x0)¹
Cond_456_0_test_LE(TRUE, x0, x1, x1)¹ ↔ 456_0_test_LE(x0, +(x1, -1), +(x1, -1))¹
456_0_test_LE(x0, x1, x1)¹ ↔ Cond_456_0_test_LE(>(x1, 0), x0, x1, x1)¹
496_0_test_LE(x0, 0, 0)¹ ↔ 528_0_test_LE(x0, x0, x0)¹
Cond_496_0_test_LE(TRUE, x0, x1, x1)¹ ↔ 496_0_test_LE(x0, +(x1, -1), +(x1, -1))¹
496_0_test_LE(x0, x1, x1)¹ ↔ Cond_496_0_test_LE(>(x1, 0), x0, x1, x1)¹
528_0_test_LE(x0, 0, 0)¹ ↔ 564_0_test_LE(x0, x0, x0)¹
Cond_528_0_test_LE(TRUE, x0, x1, x1)¹ ↔ 528_0_test_LE(x0, +(x1, -1), +(x1, -1))¹
528_0_test_LE(x0, x1, x1)¹ ↔ Cond_528_0_test_LE(>(x1, 0), x0, x1, x1)¹
564_0_test_LE(x0, 0, 0)¹ ↔ 602_0_test_LE(x0, x0, x0)¹
Cond_564_0_test_LE(TRUE, x0, x1, x1)¹ ↔ 564_0_test_LE(x0, +(x1, -1), +(x1, -1))¹
564_0_test_LE(x0, x1, x1)¹ ↔ Cond_564_0_test_LE(>(x1, 0), x0, x1, x1)¹
602_0_test_LE(x0, 0, 0)¹ ↔ 641_0_test_LE(x0, x0, x0)¹
Cond_602_0_test_LE(TRUE, x0, x1, x1)¹ ↔ 602_0_test_LE(x0, +(x1, -1), +(x1, -1))¹
602_0_test_LE(x0, x1, x1)¹ ↔ Cond_602_0_test_LE(>(x1, 0), x0, x1, x1)¹
641_0_test_LE(x0, 0, 0)¹ ↔ 680_0_test_LE(x0, x0, x0)¹
Cond_641_0_test_LE(TRUE, x0, x1, x1)¹ ↔ 641_0_test_LE(x0, +(x1, -1), +(x1, -1))¹
641_0_test_LE(x0, x1, x1)¹ ↔ Cond_641_0_test_LE(>(x1, 0), x0, x1, x1)¹
680_0_test_LE(x0, 0, 0)¹ ↔ 715_0_test_LE(x0, x0, x0)¹
Cond_680_0_test_LE(TRUE, x0, x1, x1)¹ ↔ 680_0_test_LE(x0, +(x1, -1), +(x1, -1))¹
680_0_test_LE(x0, x1, x1)¹ ↔ Cond_680_0_test_LE(>(x1, 0), x0, x1, x1)¹
715_0_test_LE(x0, 0, 0)¹ ↔ 746_0_test_LE(x0)¹
Cond_715_0_test_LE(TRUE, x0, x1, x1)¹ ↔ 715_0_test_LE(x0, +(x1, -1), +(x1, -1))¹
715_0_test_LE(x0, x1, x1)¹ ↔ Cond_715_0_test_LE(>(x1, 0), x0, x1, x1)¹
746_0_test_LE(0)¹ ↔ 751_0_test_Return¹
746_0_test_LE(x0)¹ ↔ Cond_746_0_test_LE(>(x0, 0), x0)¹
Cond_746_0_test_LE(TRUE, x0)¹ ↔ 746_0_test_LE(+(x0, -1))¹

(141) Complex Obligation (AND)

(142) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer, Boolean

The ITRS R consists of the following rules:
97_0_test_Load(x0) → 356_0_test_LE(x0, x0, x0)
356_0_test_LE(x0, x1, x1) → Cond_356_0_test_LE(x1 > 0, x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1) → 356_0_test_LE(x0, x1 + -1, x1 + -1)
356_0_test_LE(x0, 0, 0) → 389_0_test_LE(x0, x0, x0)
389_0_test_LE(x0, x1, x1) → Cond_389_0_test_LE(x1 > 0, x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1) → 389_0_test_LE(x0, x1 + -1, x1 + -1)
389_0_test_LE(x0, 0, 0) → 416_0_test_LE(x0, x0, x0)
416_0_test_LE(x0, x1, x1) → Cond_416_0_test_LE(x1 > 0, x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1) → 416_0_test_LE(x0, x1 + -1, x1 + -1)
416_0_test_LE(x0, 0, 0) → 456_0_test_LE(x0, x0, x0)
456_0_test_LE(x0, x1, x1) → Cond_456_0_test_LE(x1 > 0, x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1) → 456_0_test_LE(x0, x1 + -1, x1 + -1)
456_0_test_LE(x0, 0, 0) → 496_0_test_LE(x0, x0, x0)
496_0_test_LE(x0, x1, x1) → Cond_496_0_test_LE(x1 > 0, x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1) → 496_0_test_LE(x0, x1 + -1, x1 + -1)
496_0_test_LE(x0, 0, 0) → 528_0_test_LE(x0, x0, x0)
528_0_test_LE(x0, x1, x1) → Cond_528_0_test_LE(x1 > 0, x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1) → 528_0_test_LE(x0, x1 + -1, x1 + -1)
528_0_test_LE(x0, 0, 0) → 564_0_test_LE(x0, x0, x0)
564_0_test_LE(x0, x1, x1) → Cond_564_0_test_LE(x1 > 0, x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1) → 564_0_test_LE(x0, x1 + -1, x1 + -1)
564_0_test_LE(x0, 0, 0) → 602_0_test_LE(x0, x0, x0)
602_0_test_LE(x0, x1, x1) → Cond_602_0_test_LE(x1 > 0, x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1) → 602_0_test_LE(x0, x1 + -1, x1 + -1)
602_0_test_LE(x0, 0, 0) → 641_0_test_LE(x0, x0, x0)
641_0_test_LE(x0, x1, x1) → Cond_641_0_test_LE(x1 > 0, x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1) → 641_0_test_LE(x0, x1 + -1, x1 + -1)
641_0_test_LE(x0, 0, 0) → 680_0_test_LE(x0, x0, x0)
680_0_test_LE(x0, x1, x1) → Cond_680_0_test_LE(x1 > 0, x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1) → 680_0_test_LE(x0, x1 + -1, x1 + -1)
680_0_test_LE(x0, 0, 0) → 715_0_test_LE(x0, x0, x0)
715_0_test_LE(x0, x1, x1) → Cond_715_0_test_LE(x1 > 0, x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1) → 715_0_test_LE(x0, x1 + -1, x1 + -1)
715_0_test_LE(x0, 0, 0) → 746_0_test_LE(x0)
746_0_test_LE(0) → 751_0_test_Return
746_0_test_LE(x0) → Cond_746_0_test_LE(x0 > 0, x0)
Cond_746_0_test_LE(TRUE, x0) → 746_0_test_LE(x0 + -1)

The integer pair graph contains the following rules and edges:
(0): 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(x1[0] < 100, x0[0], x1[0])
(1): COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])
(2): 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(x1[2] > 0, 751_0_test_Return, x0[2], x1[2])
(3): COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], x1[3] + 1)
(4): 90_0_MAIN_GE(x0[4], x1[4]) → COND_90_0_MAIN_GE1(x1[4] > 99 && x0[4] > 1, x0[4], x1[4])

(3) -> (0), if (x0[3] →^* x0[0]∧x1[3] + 1 →^* x1[0])

(0) -> (1), if (x1[0] < 100 ∧x0[0] →^* x0[1]∧x1[0] →^* x1[1])

(1) -> (2), if (97_0_test_Load(x1[1]) →^* 751_0_test_Return∧x0[1] →^* x0[2]∧x1[1] →^* x1[2])

(2) -> (3), if (x1[2] > 0 ∧x0[2] →^* x0[3]∧x1[2] →^* x1[3])

(3) -> (4), if (x0[3] →^* x0[4]∧x1[3] + 1 →^* x1[4])

The set Q consists of the following terms:
97_0_test_Load(x0)
356_0_test_LE(x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1)
389_0_test_LE(x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1)
416_0_test_LE(x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1)
456_0_test_LE(x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1)
496_0_test_LE(x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1)
528_0_test_LE(x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1)
564_0_test_LE(x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1)
602_0_test_LE(x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1)
641_0_test_LE(x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1)
680_0_test_LE(x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1)
715_0_test_LE(x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1)
746_0_test_LE(x0)
Cond_746_0_test_LE(TRUE, x0)

(143) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(144) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

The ITRS R consists of the following rules:
97_0_test_Load(x0) → 356_0_test_LE(x0, x0, x0)
356_0_test_LE(x0, x1, x1) → Cond_356_0_test_LE(x1 > 0, x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1) → 356_0_test_LE(x0, x1 + -1, x1 + -1)
356_0_test_LE(x0, 0, 0) → 389_0_test_LE(x0, x0, x0)
389_0_test_LE(x0, x1, x1) → Cond_389_0_test_LE(x1 > 0, x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1) → 389_0_test_LE(x0, x1 + -1, x1 + -1)
389_0_test_LE(x0, 0, 0) → 416_0_test_LE(x0, x0, x0)
416_0_test_LE(x0, x1, x1) → Cond_416_0_test_LE(x1 > 0, x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1) → 416_0_test_LE(x0, x1 + -1, x1 + -1)
416_0_test_LE(x0, 0, 0) → 456_0_test_LE(x0, x0, x0)
456_0_test_LE(x0, x1, x1) → Cond_456_0_test_LE(x1 > 0, x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1) → 456_0_test_LE(x0, x1 + -1, x1 + -1)
456_0_test_LE(x0, 0, 0) → 496_0_test_LE(x0, x0, x0)
496_0_test_LE(x0, x1, x1) → Cond_496_0_test_LE(x1 > 0, x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1) → 496_0_test_LE(x0, x1 + -1, x1 + -1)
496_0_test_LE(x0, 0, 0) → 528_0_test_LE(x0, x0, x0)
528_0_test_LE(x0, x1, x1) → Cond_528_0_test_LE(x1 > 0, x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1) → 528_0_test_LE(x0, x1 + -1, x1 + -1)
528_0_test_LE(x0, 0, 0) → 564_0_test_LE(x0, x0, x0)
564_0_test_LE(x0, x1, x1) → Cond_564_0_test_LE(x1 > 0, x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1) → 564_0_test_LE(x0, x1 + -1, x1 + -1)
564_0_test_LE(x0, 0, 0) → 602_0_test_LE(x0, x0, x0)
602_0_test_LE(x0, x1, x1) → Cond_602_0_test_LE(x1 > 0, x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1) → 602_0_test_LE(x0, x1 + -1, x1 + -1)
602_0_test_LE(x0, 0, 0) → 641_0_test_LE(x0, x0, x0)
641_0_test_LE(x0, x1, x1) → Cond_641_0_test_LE(x1 > 0, x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1) → 641_0_test_LE(x0, x1 + -1, x1 + -1)
641_0_test_LE(x0, 0, 0) → 680_0_test_LE(x0, x0, x0)
680_0_test_LE(x0, x1, x1) → Cond_680_0_test_LE(x1 > 0, x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1) → 680_0_test_LE(x0, x1 + -1, x1 + -1)
680_0_test_LE(x0, 0, 0) → 715_0_test_LE(x0, x0, x0)
715_0_test_LE(x0, x1, x1) → Cond_715_0_test_LE(x1 > 0, x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1) → 715_0_test_LE(x0, x1 + -1, x1 + -1)
715_0_test_LE(x0, 0, 0) → 746_0_test_LE(x0)
746_0_test_LE(0) → 751_0_test_Return
746_0_test_LE(x0) → Cond_746_0_test_LE(x0 > 0, x0)
Cond_746_0_test_LE(TRUE, x0) → 746_0_test_LE(x0 + -1)

The integer pair graph contains the following rules and edges:
(3): COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], x1[3] + 1)
(2): 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(x1[2] > 0, 751_0_test_Return, x0[2], x1[2])
(1): COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])
(0): 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(x1[0] < 100, x0[0], x1[0])

(3) -> (0), if (x0[3] →^* x0[0]∧x1[3] + 1 →^* x1[0])

(0) -> (1), if (x1[0] < 100 ∧x0[0] →^* x0[1]∧x1[0] →^* x1[1])

(1) -> (2), if (97_0_test_Load(x1[1]) →^* 751_0_test_Return∧x0[1] →^* x0[2]∧x1[1] →^* x1[2])

(2) -> (3), if (x1[2] > 0 ∧x0[2] →^* x0[3]∧x1[2] →^* x1[3])

The set Q consists of the following terms:
97_0_test_Load(x0)
356_0_test_LE(x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1)
389_0_test_LE(x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1)
416_0_test_LE(x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1)
456_0_test_LE(x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1)
496_0_test_LE(x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1)
528_0_test_LE(x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1)
564_0_test_LE(x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1)
602_0_test_LE(x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1)
641_0_test_LE(x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1)
680_0_test_LE(x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1)
715_0_test_LE(x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1)
746_0_test_LE(x0)
Cond_746_0_test_LE(TRUE, x0)

(145) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1)) the following chains were created:

• We consider the chain COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1)) which results in the following constraint:
  

  (1)    (COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3])≥NonInfC∧COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3])≥90_0_MAIN_GE(x0[3], +(x1[3], 1))∧(U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥))

  
  
  We simplified constraint (1) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (2)    ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_35] = 0∧[1 + (-1)bso_36] ≥ 0)

  
  
  We simplified constraint (2) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (3)    ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_35] = 0∧[1 + (-1)bso_36] ≥ 0)

  
  
  We simplified constraint (3) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (4)    ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_35] = 0∧[1 + (-1)bso_36] ≥ 0)

  
  
  We simplified constraint (4) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (5)    ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_35] = 0∧0 = 0∧[1 + (-1)bso_36] ≥ 0)

  
  
  

For Pair 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2]) the following chains were created:

• We consider the chain 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2]), COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1)) which results in the following constraint:
  

  (6)    (>(x1[2], 0)=TRUE∧x0[2]=x0[3]∧x1[2]=x1[3] ⇒ 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2])≥NonInfC∧97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2])≥COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])∧(U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥))

  
  
  We simplified constraint (6) using rule (IV) which results in the following new constraint:
  

  (7)    (>(x1[2], 0)=TRUE ⇒ 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2])≥NonInfC∧97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2])≥COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])∧(U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    (x1[2] + [-1] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-1)bni_37 + (-1)Bound*bni_37] + [(-1)bni_37]x1[2] ≥ 0∧[(-1)bso_38] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    (x1[2] + [-1] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-1)bni_37 + (-1)Bound*bni_37] + [(-1)bni_37]x1[2] ≥ 0∧[(-1)bso_38] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    (x1[2] + [-1] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-1)bni_37 + (-1)Bound*bni_37] + [(-1)bni_37]x1[2] ≥ 0∧[(-1)bso_38] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (11)    (x1[2] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-2)bni_37 + (-1)Bound*bni_37] + [(-1)bni_37]x1[2] ≥ 0∧[(-1)bso_38] ≥ 0)

  
  
  

For Pair COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1]) the following chains were created:

• We consider the chain COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1]) which results in the following constraint:
  

  (12)    (COND_90_0_MAIN_GE(TRUE, x0[1], x1[1])≥NonInfC∧COND_90_0_MAIN_GE(TRUE, x0[1], x1[1])≥97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])∧(U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥))

  
  
  We simplified constraint (12) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (13)    ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_39] = 0∧[(-1)bso_40] ≥ 0)

  
  
  We simplified constraint (13) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (14)    ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_39] = 0∧[(-1)bso_40] ≥ 0)

  
  
  We simplified constraint (14) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (15)    ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_39] = 0∧[(-1)bso_40] ≥ 0)

  
  
  We simplified constraint (15) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (16)    ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_39] = 0∧0 = 0∧[(-1)bso_40] ≥ 0)

  
  
  

For Pair 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0]) the following chains were created:

• We consider the chain 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0]), COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1]) which results in the following constraint:
  

  (17)    (<(x1[0], 100)=TRUE∧x0[0]=x0[1]∧x1[0]=x1[1] ⇒ 90_0_MAIN_GE(x0[0], x1[0])≥NonInfC∧90_0_MAIN_GE(x0[0], x1[0])≥COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])∧(U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥))

  
  
  We simplified constraint (17) using rule (IV) which results in the following new constraint:
  

  (18)    (<(x1[0], 100)=TRUE ⇒ 90_0_MAIN_GE(x0[0], x1[0])≥NonInfC∧90_0_MAIN_GE(x0[0], x1[0])≥COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])∧(U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥))

  
  
  We simplified constraint (18) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (19)    ([99] + [-1]x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_41 + (-1)Bound*bni_41] + [(-1)bni_41]x1[0] ≥ 0∧[(-1)bso_42] ≥ 0)

  
  
  We simplified constraint (19) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (20)    ([99] + [-1]x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_41 + (-1)Bound*bni_41] + [(-1)bni_41]x1[0] ≥ 0∧[(-1)bso_42] ≥ 0)

  
  
  We simplified constraint (20) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (21)    ([99] + [-1]x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_41 + (-1)Bound*bni_41] + [(-1)bni_41]x1[0] ≥ 0∧[(-1)bso_42] ≥ 0)

  
  
  We simplified constraint (21) using rule (IDP_SMT_SPLIT) which results in the following new constraints:
  

  (22)    ([99] + [-1]x1[0] ≥ 0∧x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_41 + (-1)Bound*bni_41] + [(-1)bni_41]x1[0] ≥ 0∧[(-1)bso_42] ≥ 0)

  
  

  (23)    ([99] + x1[0] ≥ 0∧x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_41 + (-1)Bound*bni_41] + [bni_41]x1[0] ≥ 0∧[(-1)bso_42] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1))
  
  • ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_35] = 0∧0 = 0∧[1 + (-1)bso_36] ≥ 0)
    
  
  
• 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])
  
  • (x1[2] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-2)bni_37 + (-1)Bound*bni_37] + [(-1)bni_37]x1[2] ≥ 0∧[(-1)bso_38] ≥ 0)
    
  
  
• COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])
  
  • ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_39] = 0∧0 = 0∧[(-1)bso_40] ≥ 0)
    
  
  
• 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])
  
  • ([99] + [-1]x1[0] ≥ 0∧x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_41 + (-1)Bound*bni_41] + [(-1)bni_41]x1[0] ≥ 0∧[(-1)bso_42] ≥ 0)
    
  • ([99] + x1[0] ≥ 0∧x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_41 + (-1)Bound*bni_41] + [bni_41]x1[0] ≥ 0∧[(-1)bso_42] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(97_0_test_Load(x₁)) = [-1] + x₁   
POL(356_0_test_LE(x₁, x₂, x₃)) = [1] + [-1]x₃ + x₂   
POL(Cond_356_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [-1]x₃ + x₂   
POL(>(x₁, x₂)) = [-1]   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   
POL(389_0_test_LE(x₁, x₂, x₃)) = [1] + [-1]x₃ + [-1]x₂ + [-1]x₁   
POL(Cond_389_0_test_LE(x₁, x₂, x₃, x₄)) = x₄ + [-1]x₃ + x₂   
POL(416_0_test_LE(x₁, x₂, x₃)) = [2] + [2]x₃ + [-1]x₂   
POL(Cond_416_0_test_LE(x₁, x₂, x₃, x₄)) = [2]x₃ + x₂   
POL(456_0_test_LE(x₁, x₂, x₃)) = [-1]x₂   
POL(Cond_456_0_test_LE(x₁, x₂, x₃, x₄)) = [2]x₄ + x₂   
POL(496_0_test_LE(x₁, x₂, x₃)) = [-1] + [-1]x₃ + [-1]x₂ + [-1]x₁   
POL(Cond_496_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [2]x₄ + [-1]x₃ + x₂   
POL(528_0_test_LE(x₁, x₂, x₃)) = [-1] + [-1]x₃ + [-1]x₂ + [-1]x₁   
POL(Cond_528_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [2]x₄ + [-1]x₃ + x₂   
POL(564_0_test_LE(x₁, x₂, x₃)) = [1] + [2]x₃ + x₂   
POL(Cond_564_0_test_LE(x₁, x₂, x₃, x₄)) = [2] + [2]x₃ + x₂   
POL(602_0_test_LE(x₁, x₂, x₃)) = [2] + [-1]x₃ + [-1]x₁   
POL(Cond_602_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [-1]x₄ + [-1]x₃ + x₂   
POL(641_0_test_LE(x₁, x₂, x₃)) = [-1]x₃ + [-1]x₂   
POL(Cond_641_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [-1]x₃ + x₂   
POL(680_0_test_LE(x₁, x₂, x₃)) = [-1]x₃ + [-1]x₂ + [2]x₁   
POL(Cond_680_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [2]x₄ + [-1]x₃ + x₂   
POL(715_0_test_LE(x₁, x₂, x₃)) = [-1]x₃ + [-1]x₂ + x₁   
POL(Cond_715_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [2]x₄ + [-1]x₃ + x₂   
POL(746_0_test_LE(x₁)) = 0   
POL(751_0_test_Return) = [-1]   
POL(Cond_746_0_test_LE(x₁, x₂)) = [2] + x₂   
POL(COND_97_1_MAIN_INVOKEMETHOD(x₁, x₂, x₃, x₄)) = [-1] + [-1]x₄   
POL(90_0_MAIN_GE(x₁, x₂)) = [-1] + [-1]x₂   
POL(1) = [1]   
POL(97_1_MAIN_INVOKEMETHOD(x₁, x₂, x₃)) = [-1] + [-1]x₃   
POL(COND_90_0_MAIN_GE(x₁, x₂, x₃)) = [-1] + [-1]x₃   
POL(<(x₁, x₂)) = [-1]   
POL(100) = [100]   

The following pairs are in P_>:

COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1))

The following pairs are in P_bound:

90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])

The following pairs are in P_≥:

97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])
COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])
90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])

At least the following rules have been oriented under context sensitive arithmetic replacement:

680_0_test_LE(x0, x0, x0)¹ → 641_0_test_LE(x0, 0, 0)¹
746_0_test_LE(0)¹ → 751_0_test_Return¹

(146) Complex Obligation (AND)

(147) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

The ITRS R consists of the following rules:
97_0_test_Load(x0) → 356_0_test_LE(x0, x0, x0)
356_0_test_LE(x0, x1, x1) → Cond_356_0_test_LE(x1 > 0, x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1) → 356_0_test_LE(x0, x1 + -1, x1 + -1)
356_0_test_LE(x0, 0, 0) → 389_0_test_LE(x0, x0, x0)
389_0_test_LE(x0, x1, x1) → Cond_389_0_test_LE(x1 > 0, x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1) → 389_0_test_LE(x0, x1 + -1, x1 + -1)
389_0_test_LE(x0, 0, 0) → 416_0_test_LE(x0, x0, x0)
416_0_test_LE(x0, x1, x1) → Cond_416_0_test_LE(x1 > 0, x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1) → 416_0_test_LE(x0, x1 + -1, x1 + -1)
416_0_test_LE(x0, 0, 0) → 456_0_test_LE(x0, x0, x0)
456_0_test_LE(x0, x1, x1) → Cond_456_0_test_LE(x1 > 0, x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1) → 456_0_test_LE(x0, x1 + -1, x1 + -1)
456_0_test_LE(x0, 0, 0) → 496_0_test_LE(x0, x0, x0)
496_0_test_LE(x0, x1, x1) → Cond_496_0_test_LE(x1 > 0, x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1) → 496_0_test_LE(x0, x1 + -1, x1 + -1)
496_0_test_LE(x0, 0, 0) → 528_0_test_LE(x0, x0, x0)
528_0_test_LE(x0, x1, x1) → Cond_528_0_test_LE(x1 > 0, x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1) → 528_0_test_LE(x0, x1 + -1, x1 + -1)
528_0_test_LE(x0, 0, 0) → 564_0_test_LE(x0, x0, x0)
564_0_test_LE(x0, x1, x1) → Cond_564_0_test_LE(x1 > 0, x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1) → 564_0_test_LE(x0, x1 + -1, x1 + -1)
564_0_test_LE(x0, 0, 0) → 602_0_test_LE(x0, x0, x0)
602_0_test_LE(x0, x1, x1) → Cond_602_0_test_LE(x1 > 0, x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1) → 602_0_test_LE(x0, x1 + -1, x1 + -1)
602_0_test_LE(x0, 0, 0) → 641_0_test_LE(x0, x0, x0)
641_0_test_LE(x0, x1, x1) → Cond_641_0_test_LE(x1 > 0, x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1) → 641_0_test_LE(x0, x1 + -1, x1 + -1)
641_0_test_LE(x0, 0, 0) → 680_0_test_LE(x0, x0, x0)
680_0_test_LE(x0, x1, x1) → Cond_680_0_test_LE(x1 > 0, x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1) → 680_0_test_LE(x0, x1 + -1, x1 + -1)
680_0_test_LE(x0, 0, 0) → 715_0_test_LE(x0, x0, x0)
715_0_test_LE(x0, x1, x1) → Cond_715_0_test_LE(x1 > 0, x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1) → 715_0_test_LE(x0, x1 + -1, x1 + -1)
715_0_test_LE(x0, 0, 0) → 746_0_test_LE(x0)
746_0_test_LE(0) → 751_0_test_Return
746_0_test_LE(x0) → Cond_746_0_test_LE(x0 > 0, x0)
Cond_746_0_test_LE(TRUE, x0) → 746_0_test_LE(x0 + -1)

The integer pair graph contains the following rules and edges:
(2): 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(x1[2] > 0, 751_0_test_Return, x0[2], x1[2])
(1): COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])
(0): 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(x1[0] < 100, x0[0], x1[0])

(0) -> (1), if (x1[0] < 100 ∧x0[0] →^* x0[1]∧x1[0] →^* x1[1])

(1) -> (2), if (97_0_test_Load(x1[1]) →^* 751_0_test_Return∧x0[1] →^* x0[2]∧x1[1] →^* x1[2])

The set Q consists of the following terms:
97_0_test_Load(x0)
356_0_test_LE(x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1)
389_0_test_LE(x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1)
416_0_test_LE(x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1)
456_0_test_LE(x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1)
496_0_test_LE(x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1)
528_0_test_LE(x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1)
564_0_test_LE(x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1)
602_0_test_LE(x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1)
641_0_test_LE(x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1)
680_0_test_LE(x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1)
715_0_test_LE(x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1)
746_0_test_LE(x0)
Cond_746_0_test_LE(TRUE, x0)

(148) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 3 less nodes.

(149) TRUE

(150) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

The ITRS R consists of the following rules:
97_0_test_Load(x0) → 356_0_test_LE(x0, x0, x0)
356_0_test_LE(x0, x1, x1) → Cond_356_0_test_LE(x1 > 0, x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1) → 356_0_test_LE(x0, x1 + -1, x1 + -1)
356_0_test_LE(x0, 0, 0) → 389_0_test_LE(x0, x0, x0)
389_0_test_LE(x0, x1, x1) → Cond_389_0_test_LE(x1 > 0, x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1) → 389_0_test_LE(x0, x1 + -1, x1 + -1)
389_0_test_LE(x0, 0, 0) → 416_0_test_LE(x0, x0, x0)
416_0_test_LE(x0, x1, x1) → Cond_416_0_test_LE(x1 > 0, x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1) → 416_0_test_LE(x0, x1 + -1, x1 + -1)
416_0_test_LE(x0, 0, 0) → 456_0_test_LE(x0, x0, x0)
456_0_test_LE(x0, x1, x1) → Cond_456_0_test_LE(x1 > 0, x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1) → 456_0_test_LE(x0, x1 + -1, x1 + -1)
456_0_test_LE(x0, 0, 0) → 496_0_test_LE(x0, x0, x0)
496_0_test_LE(x0, x1, x1) → Cond_496_0_test_LE(x1 > 0, x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1) → 496_0_test_LE(x0, x1 + -1, x1 + -1)
496_0_test_LE(x0, 0, 0) → 528_0_test_LE(x0, x0, x0)
528_0_test_LE(x0, x1, x1) → Cond_528_0_test_LE(x1 > 0, x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1) → 528_0_test_LE(x0, x1 + -1, x1 + -1)
528_0_test_LE(x0, 0, 0) → 564_0_test_LE(x0, x0, x0)
564_0_test_LE(x0, x1, x1) → Cond_564_0_test_LE(x1 > 0, x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1) → 564_0_test_LE(x0, x1 + -1, x1 + -1)
564_0_test_LE(x0, 0, 0) → 602_0_test_LE(x0, x0, x0)
602_0_test_LE(x0, x1, x1) → Cond_602_0_test_LE(x1 > 0, x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1) → 602_0_test_LE(x0, x1 + -1, x1 + -1)
602_0_test_LE(x0, 0, 0) → 641_0_test_LE(x0, x0, x0)
641_0_test_LE(x0, x1, x1) → Cond_641_0_test_LE(x1 > 0, x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1) → 641_0_test_LE(x0, x1 + -1, x1 + -1)
641_0_test_LE(x0, 0, 0) → 680_0_test_LE(x0, x0, x0)
680_0_test_LE(x0, x1, x1) → Cond_680_0_test_LE(x1 > 0, x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1) → 680_0_test_LE(x0, x1 + -1, x1 + -1)
680_0_test_LE(x0, 0, 0) → 715_0_test_LE(x0, x0, x0)
715_0_test_LE(x0, x1, x1) → Cond_715_0_test_LE(x1 > 0, x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1) → 715_0_test_LE(x0, x1 + -1, x1 + -1)
715_0_test_LE(x0, 0, 0) → 746_0_test_LE(x0)
746_0_test_LE(0) → 751_0_test_Return
746_0_test_LE(x0) → Cond_746_0_test_LE(x0 > 0, x0)
Cond_746_0_test_LE(TRUE, x0) → 746_0_test_LE(x0 + -1)

The integer pair graph contains the following rules and edges:
(3): COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], x1[3] + 1)
(2): 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(x1[2] > 0, 751_0_test_Return, x0[2], x1[2])
(1): COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])

(1) -> (2), if (97_0_test_Load(x1[1]) →^* 751_0_test_Return∧x0[1] →^* x0[2]∧x1[1] →^* x1[2])

(2) -> (3), if (x1[2] > 0 ∧x0[2] →^* x0[3]∧x1[2] →^* x1[3])

The set Q consists of the following terms:
97_0_test_Load(x0)
356_0_test_LE(x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1)
389_0_test_LE(x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1)
416_0_test_LE(x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1)
456_0_test_LE(x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1)
496_0_test_LE(x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1)
528_0_test_LE(x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1)
564_0_test_LE(x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1)
602_0_test_LE(x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1)
641_0_test_LE(x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1)
680_0_test_LE(x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1)
715_0_test_LE(x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1)
746_0_test_LE(x0)
Cond_746_0_test_LE(TRUE, x0)

(151) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 3 less nodes.

(152) TRUE

(153) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

The ITRS R consists of the following rules:
97_0_test_Load(x0) → 356_0_test_LE(x0, x0, x0)
356_0_test_LE(x0, x1, x1) → Cond_356_0_test_LE(x1 > 0, x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1) → 356_0_test_LE(x0, x1 + -1, x1 + -1)
356_0_test_LE(x0, 0, 0) → 389_0_test_LE(x0, x0, x0)
389_0_test_LE(x0, x1, x1) → Cond_389_0_test_LE(x1 > 0, x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1) → 389_0_test_LE(x0, x1 + -1, x1 + -1)
389_0_test_LE(x0, 0, 0) → 416_0_test_LE(x0, x0, x0)
416_0_test_LE(x0, x1, x1) → Cond_416_0_test_LE(x1 > 0, x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1) → 416_0_test_LE(x0, x1 + -1, x1 + -1)
416_0_test_LE(x0, 0, 0) → 456_0_test_LE(x0, x0, x0)
456_0_test_LE(x0, x1, x1) → Cond_456_0_test_LE(x1 > 0, x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1) → 456_0_test_LE(x0, x1 + -1, x1 + -1)
456_0_test_LE(x0, 0, 0) → 496_0_test_LE(x0, x0, x0)
496_0_test_LE(x0, x1, x1) → Cond_496_0_test_LE(x1 > 0, x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1) → 496_0_test_LE(x0, x1 + -1, x1 + -1)
496_0_test_LE(x0, 0, 0) → 528_0_test_LE(x0, x0, x0)
528_0_test_LE(x0, x1, x1) → Cond_528_0_test_LE(x1 > 0, x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1) → 528_0_test_LE(x0, x1 + -1, x1 + -1)
528_0_test_LE(x0, 0, 0) → 564_0_test_LE(x0, x0, x0)
564_0_test_LE(x0, x1, x1) → Cond_564_0_test_LE(x1 > 0, x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1) → 564_0_test_LE(x0, x1 + -1, x1 + -1)
564_0_test_LE(x0, 0, 0) → 602_0_test_LE(x0, x0, x0)
602_0_test_LE(x0, x1, x1) → Cond_602_0_test_LE(x1 > 0, x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1) → 602_0_test_LE(x0, x1 + -1, x1 + -1)
602_0_test_LE(x0, 0, 0) → 641_0_test_LE(x0, x0, x0)
641_0_test_LE(x0, x1, x1) → Cond_641_0_test_LE(x1 > 0, x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1) → 641_0_test_LE(x0, x1 + -1, x1 + -1)
641_0_test_LE(x0, 0, 0) → 680_0_test_LE(x0, x0, x0)
680_0_test_LE(x0, x1, x1) → Cond_680_0_test_LE(x1 > 0, x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1) → 680_0_test_LE(x0, x1 + -1, x1 + -1)
680_0_test_LE(x0, 0, 0) → 715_0_test_LE(x0, x0, x0)
715_0_test_LE(x0, x1, x1) → Cond_715_0_test_LE(x1 > 0, x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1) → 715_0_test_LE(x0, x1 + -1, x1 + -1)
715_0_test_LE(x0, 0, 0) → 746_0_test_LE(x0)
746_0_test_LE(0) → 751_0_test_Return
746_0_test_LE(x0) → Cond_746_0_test_LE(x0 > 0, x0)
Cond_746_0_test_LE(TRUE, x0) → 746_0_test_LE(x0 + -1)

The integer pair graph contains the following rules and edges:
(0): 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(x1[0] < 100, x0[0], x1[0])
(1): COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])
(2): 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(x1[2] > 0, 751_0_test_Return, x0[2], x1[2])
(3): COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], x1[3] + 1)
(5): COND_90_0_MAIN_GE1(TRUE, x0[5], x1[5]) → 90_0_MAIN_GE(x0[5] - 1, x0[5] - 1)

(3) -> (0), if (x0[3] →^* x0[0]∧x1[3] + 1 →^* x1[0])

(5) -> (0), if (x0[5] - 1 →^* x0[0]∧x0[5] - 1 →^* x1[0])

(0) -> (1), if (x1[0] < 100 ∧x0[0] →^* x0[1]∧x1[0] →^* x1[1])

(1) -> (2), if (97_0_test_Load(x1[1]) →^* 751_0_test_Return∧x0[1] →^* x0[2]∧x1[1] →^* x1[2])

(2) -> (3), if (x1[2] > 0 ∧x0[2] →^* x0[3]∧x1[2] →^* x1[3])

The set Q consists of the following terms:
97_0_test_Load(x0)
356_0_test_LE(x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1)
389_0_test_LE(x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1)
416_0_test_LE(x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1)
456_0_test_LE(x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1)
496_0_test_LE(x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1)
528_0_test_LE(x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1)
564_0_test_LE(x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1)
602_0_test_LE(x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1)
641_0_test_LE(x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1)
680_0_test_LE(x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1)
715_0_test_LE(x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1)
746_0_test_LE(x0)
Cond_746_0_test_LE(TRUE, x0)

(154) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(155) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

The ITRS R consists of the following rules:
97_0_test_Load(x0) → 356_0_test_LE(x0, x0, x0)
356_0_test_LE(x0, x1, x1) → Cond_356_0_test_LE(x1 > 0, x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1) → 356_0_test_LE(x0, x1 + -1, x1 + -1)
356_0_test_LE(x0, 0, 0) → 389_0_test_LE(x0, x0, x0)
389_0_test_LE(x0, x1, x1) → Cond_389_0_test_LE(x1 > 0, x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1) → 389_0_test_LE(x0, x1 + -1, x1 + -1)
389_0_test_LE(x0, 0, 0) → 416_0_test_LE(x0, x0, x0)
416_0_test_LE(x0, x1, x1) → Cond_416_0_test_LE(x1 > 0, x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1) → 416_0_test_LE(x0, x1 + -1, x1 + -1)
416_0_test_LE(x0, 0, 0) → 456_0_test_LE(x0, x0, x0)
456_0_test_LE(x0, x1, x1) → Cond_456_0_test_LE(x1 > 0, x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1) → 456_0_test_LE(x0, x1 + -1, x1 + -1)
456_0_test_LE(x0, 0, 0) → 496_0_test_LE(x0, x0, x0)
496_0_test_LE(x0, x1, x1) → Cond_496_0_test_LE(x1 > 0, x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1) → 496_0_test_LE(x0, x1 + -1, x1 + -1)
496_0_test_LE(x0, 0, 0) → 528_0_test_LE(x0, x0, x0)
528_0_test_LE(x0, x1, x1) → Cond_528_0_test_LE(x1 > 0, x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1) → 528_0_test_LE(x0, x1 + -1, x1 + -1)
528_0_test_LE(x0, 0, 0) → 564_0_test_LE(x0, x0, x0)
564_0_test_LE(x0, x1, x1) → Cond_564_0_test_LE(x1 > 0, x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1) → 564_0_test_LE(x0, x1 + -1, x1 + -1)
564_0_test_LE(x0, 0, 0) → 602_0_test_LE(x0, x0, x0)
602_0_test_LE(x0, x1, x1) → Cond_602_0_test_LE(x1 > 0, x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1) → 602_0_test_LE(x0, x1 + -1, x1 + -1)
602_0_test_LE(x0, 0, 0) → 641_0_test_LE(x0, x0, x0)
641_0_test_LE(x0, x1, x1) → Cond_641_0_test_LE(x1 > 0, x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1) → 641_0_test_LE(x0, x1 + -1, x1 + -1)
641_0_test_LE(x0, 0, 0) → 680_0_test_LE(x0, x0, x0)
680_0_test_LE(x0, x1, x1) → Cond_680_0_test_LE(x1 > 0, x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1) → 680_0_test_LE(x0, x1 + -1, x1 + -1)
680_0_test_LE(x0, 0, 0) → 715_0_test_LE(x0, x0, x0)
715_0_test_LE(x0, x1, x1) → Cond_715_0_test_LE(x1 > 0, x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1) → 715_0_test_LE(x0, x1 + -1, x1 + -1)
715_0_test_LE(x0, 0, 0) → 746_0_test_LE(x0)
746_0_test_LE(0) → 751_0_test_Return
746_0_test_LE(x0) → Cond_746_0_test_LE(x0 > 0, x0)
Cond_746_0_test_LE(TRUE, x0) → 746_0_test_LE(x0 + -1)

The integer pair graph contains the following rules and edges:
(3): COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], x1[3] + 1)
(2): 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(x1[2] > 0, 751_0_test_Return, x0[2], x1[2])
(1): COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])
(0): 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(x1[0] < 100, x0[0], x1[0])

(3) -> (0), if (x0[3] →^* x0[0]∧x1[3] + 1 →^* x1[0])

(0) -> (1), if (x1[0] < 100 ∧x0[0] →^* x0[1]∧x1[0] →^* x1[1])

(1) -> (2), if (97_0_test_Load(x1[1]) →^* 751_0_test_Return∧x0[1] →^* x0[2]∧x1[1] →^* x1[2])

(2) -> (3), if (x1[2] > 0 ∧x0[2] →^* x0[3]∧x1[2] →^* x1[3])

The set Q consists of the following terms:
97_0_test_Load(x0)
356_0_test_LE(x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1)
389_0_test_LE(x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1)
416_0_test_LE(x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1)
456_0_test_LE(x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1)
496_0_test_LE(x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1)
528_0_test_LE(x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1)
564_0_test_LE(x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1)
602_0_test_LE(x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1)
641_0_test_LE(x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1)
680_0_test_LE(x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1)
715_0_test_LE(x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1)
746_0_test_LE(x0)
Cond_746_0_test_LE(TRUE, x0)

(156) IDPNonInfProof (SOUND transformation)

Used the following options for this NonInfProof:
IDPGPoloSolver: Range: [(-1,2)] IsNat: false Interpretation Shape Heuristic: aprove.DPFramework.IDPProblem.Processors.nonInf.poly.IdpCand1ShapeHeuristic@66311578 Constraint Generator: NonInfConstraintGenerator: PathGenerator: MetricPathGenerator: Max Left Steps: 0 Max Right Steps: 0

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1)) the following chains were created:

• We consider the chain COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1)) which results in the following constraint:
  

  (1)    (COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3])≥NonInfC∧COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3])≥90_0_MAIN_GE(x0[3], +(x1[3], 1))∧(U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥))

  
  
  We simplified constraint (1) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (2)    ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_36] = 0∧[1 + (-1)bso_37] ≥ 0)

  
  
  We simplified constraint (2) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (3)    ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_36] = 0∧[1 + (-1)bso_37] ≥ 0)

  
  
  We simplified constraint (3) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (4)    ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_36] = 0∧[1 + (-1)bso_37] ≥ 0)

  
  
  We simplified constraint (4) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (5)    ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_36] = 0∧0 = 0∧[1 + (-1)bso_37] ≥ 0)

  
  
  

For Pair 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2]) the following chains were created:

• We consider the chain 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2]), COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1)) which results in the following constraint:
  

  (6)    (>(x1[2], 0)=TRUE∧x0[2]=x0[3]∧x1[2]=x1[3] ⇒ 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2])≥NonInfC∧97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2])≥COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])∧(U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥))

  
  
  We simplified constraint (6) using rule (IV) which results in the following new constraint:
  

  (7)    (>(x1[2], 0)=TRUE ⇒ 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2])≥NonInfC∧97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2])≥COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])∧(U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥))

  
  
  We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (8)    (x1[2] + [-1] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-1)bni_38 + (-1)Bound*bni_38] + [(-1)bni_38]x1[2] ≥ 0∧[(-1)bso_39] ≥ 0)

  
  
  We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (9)    (x1[2] + [-1] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-1)bni_38 + (-1)Bound*bni_38] + [(-1)bni_38]x1[2] ≥ 0∧[(-1)bso_39] ≥ 0)

  
  
  We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (10)    (x1[2] + [-1] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-1)bni_38 + (-1)Bound*bni_38] + [(-1)bni_38]x1[2] ≥ 0∧[(-1)bso_39] ≥ 0)

  
  
  We simplified constraint (10) using rule (IDP_SMT_SPLIT) which results in the following new constraint:
  

  (11)    (x1[2] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-2)bni_38 + (-1)Bound*bni_38] + [(-1)bni_38]x1[2] ≥ 0∧[(-1)bso_39] ≥ 0)

  
  
  

For Pair COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1]) the following chains were created:

• We consider the chain COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1]) which results in the following constraint:
  

  (12)    (COND_90_0_MAIN_GE(TRUE, x0[1], x1[1])≥NonInfC∧COND_90_0_MAIN_GE(TRUE, x0[1], x1[1])≥97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])∧(U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥))

  
  
  We simplified constraint (12) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (13)    ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_40] = 0∧[(-1)bso_41] ≥ 0)

  
  
  We simplified constraint (13) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (14)    ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_40] = 0∧[(-1)bso_41] ≥ 0)

  
  
  We simplified constraint (14) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (15)    ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_40] = 0∧[(-1)bso_41] ≥ 0)

  
  
  We simplified constraint (15) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:
  

  (16)    ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_40] = 0∧0 = 0∧[(-1)bso_41] ≥ 0)

  
  
  

For Pair 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0]) the following chains were created:

• We consider the chain 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0]), COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1]) which results in the following constraint:
  

  (17)    (<(x1[0], 100)=TRUE∧x0[0]=x0[1]∧x1[0]=x1[1] ⇒ 90_0_MAIN_GE(x0[0], x1[0])≥NonInfC∧90_0_MAIN_GE(x0[0], x1[0])≥COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])∧(U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥))

  
  
  We simplified constraint (17) using rule (IV) which results in the following new constraint:
  

  (18)    (<(x1[0], 100)=TRUE ⇒ 90_0_MAIN_GE(x0[0], x1[0])≥NonInfC∧90_0_MAIN_GE(x0[0], x1[0])≥COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])∧(U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥))

  
  
  We simplified constraint (18) using rule (POLY_CONSTRAINTS) which results in the following new constraint:
  

  (19)    ([99] + [-1]x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_42 + (-1)Bound*bni_42] + [(-1)bni_42]x1[0] ≥ 0∧[(-1)bso_43] ≥ 0)

  
  
  We simplified constraint (19) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:
  

  (20)    ([99] + [-1]x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_42 + (-1)Bound*bni_42] + [(-1)bni_42]x1[0] ≥ 0∧[(-1)bso_43] ≥ 0)

  
  
  We simplified constraint (20) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:
  

  (21)    ([99] + [-1]x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_42 + (-1)Bound*bni_42] + [(-1)bni_42]x1[0] ≥ 0∧[(-1)bso_43] ≥ 0)

  
  
  We simplified constraint (21) using rule (IDP_SMT_SPLIT) which results in the following new constraints:
  

  (22)    ([99] + [-1]x1[0] ≥ 0∧x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_42 + (-1)Bound*bni_42] + [(-1)bni_42]x1[0] ≥ 0∧[(-1)bso_43] ≥ 0)

  
  

  (23)    ([99] + x1[0] ≥ 0∧x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_42 + (-1)Bound*bni_42] + [bni_42]x1[0] ≥ 0∧[(-1)bso_43] ≥ 0)

  
  
  

To summarize, we get the following constraints P_≥ for the following pairs.

• COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1))
  
  • ((U^Increasing(90_0_MAIN_GE(x0[3], +(x1[3], 1))), ≥)∧[bni_36] = 0∧0 = 0∧[1 + (-1)bso_37] ≥ 0)
    
  
  
• 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])
  
  • (x1[2] ≥ 0 ⇒ (U^Increasing(COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])), ≥)∧[(-2)bni_38 + (-1)Bound*bni_38] + [(-1)bni_38]x1[2] ≥ 0∧[(-1)bso_39] ≥ 0)
    
  
  
• COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])
  
  • ((U^Increasing(97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])), ≥)∧[bni_40] = 0∧0 = 0∧[(-1)bso_41] ≥ 0)
    
  
  
• 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])
  
  • ([99] + [-1]x1[0] ≥ 0∧x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_42 + (-1)Bound*bni_42] + [(-1)bni_42]x1[0] ≥ 0∧[(-1)bso_43] ≥ 0)
    
  • ([99] + x1[0] ≥ 0∧x1[0] ≥ 0 ⇒ (U^Increasing(COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])), ≥)∧[(-1)bni_42 + (-1)Bound*bni_42] + [bni_42]x1[0] ≥ 0∧[(-1)bso_43] ≥ 0)
    
  
  

The constraints for P_> respective P_bound are constructed from P_≥ where we just replace every occurence of "t ≥ s" in P_≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for P_bound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(97_0_test_Load(x₁)) = [-1] + [-1]x₁   
POL(356_0_test_LE(x₁, x₂, x₃)) = [-1] + [-1]x₂ + [-1]x₁   
POL(Cond_356_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [-1]x₄ + [-1]x₂   
POL(>(x₁, x₂)) = 0   
POL(0) = 0   
POL(+(x₁, x₂)) = x₁ + x₂   
POL(-1) = [-1]   
POL(389_0_test_LE(x₁, x₂, x₃)) = [-1] + [-1]x₃ + [-1]x₂ + [-1]x₁   
POL(Cond_389_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [2]x₄ + [-1]x₃ + [-1]x₂   
POL(416_0_test_LE(x₁, x₂, x₃)) = [-1]x₃ + [-1]x₂ + x₁   
POL(Cond_416_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [-1]x₄ + [-1]x₃ + [-1]x₂   
POL(456_0_test_LE(x₁, x₂, x₃)) = [-1] + [-1]x₃ + [-1]x₂ + [-1]x₁   
POL(Cond_456_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [-1]x₄ + [-1]x₃ + [-1]x₂   
POL(496_0_test_LE(x₁, x₂, x₃)) = [-1] + [-1]x₃ + [-1]x₂ + [-1]x₁   
POL(Cond_496_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [2]x₄ + [-1]x₃ + [-1]x₂   
POL(528_0_test_LE(x₁, x₂, x₃)) = [-1] + [-1]x₃ + [-1]x₂ + x₁   
POL(Cond_528_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [2]x₄ + [-1]x₃ + [-1]x₂   
POL(564_0_test_LE(x₁, x₂, x₃)) = [2] + [-1]x₃ + x₂ + [-1]x₁   
POL(Cond_564_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [-1]x₄ + [-1]x₃ + [-1]x₂   
POL(602_0_test_LE(x₁, x₂, x₃)) = [-1] + [-1]x₃ + [-1]x₂ + [-1]x₁   
POL(Cond_602_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [2]x₄ + [-1]x₃ + [-1]x₂   
POL(641_0_test_LE(x₁, x₂, x₃)) = [1] + [-1]x₃ + [-1]x₂ + [-1]x₁   
POL(Cond_641_0_test_LE(x₁, x₂, x₃, x₄)) = [1] + [-1]x₄ + [-1]x₃ + [-1]x₂   
POL(680_0_test_LE(x₁, x₂, x₃)) = [-1] + [-1]x₃ + [-1]x₂ + [2]x₁   
POL(Cond_680_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [2]x₄ + [-1]x₃ + [-1]x₂   
POL(715_0_test_LE(x₁, x₂, x₃)) = [-1] + [-1]x₃ + [-1]x₂ + [-1]x₁   
POL(Cond_715_0_test_LE(x₁, x₂, x₃, x₄)) = [-1] + [2]x₄ + [-1]x₃ + [-1]x₂   
POL(746_0_test_LE(x₁)) = [-1]   
POL(751_0_test_Return) = [2]   
POL(Cond_746_0_test_LE(x₁, x₂)) = [-1] + [-1]x₂   
POL(COND_97_1_MAIN_INVOKEMETHOD(x₁, x₂, x₃, x₄)) = [-1] + [-1]x₄   
POL(90_0_MAIN_GE(x₁, x₂)) = [-1] + [-1]x₂   
POL(1) = [1]   
POL(97_1_MAIN_INVOKEMETHOD(x₁, x₂, x₃)) = [-1] + [-1]x₃   
POL(COND_90_0_MAIN_GE(x₁, x₂, x₃)) = [-1] + [-1]x₃   
POL(<(x₁, x₂)) = [2]   
POL(100) = [100]   

The following pairs are in P_>:

COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], +(x1[3], 1))

The following pairs are in P_bound:

90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])

The following pairs are in P_≥:

97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(>(x1[2], 0), 751_0_test_Return, x0[2], x1[2])
COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])
90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(<(x1[0], 100), x0[0], x1[0])

At least the following rules have been oriented under context sensitive arithmetic replacement:

416_0_test_LE(x0, x0, x0)¹ → 389_0_test_LE(x0, 0, 0)¹
456_0_test_LE(x0, +(x1, -1), +(x1, -1))¹ → Cond_456_0_test_LE(TRUE, x0, x1, x1)¹
456_0_test_LE(x0, x1, x1)¹ ↔ Cond_456_0_test_LE(>(x1, 0), x0, x1, x1)¹
528_0_test_LE(x0, x0, x0)¹ → 496_0_test_LE(x0, 0, 0)¹
641_0_test_LE(x0, +(x1, -1), +(x1, -1))¹ → Cond_641_0_test_LE(TRUE, x0, x1, x1)¹
641_0_test_LE(x0, x1, x1)¹ ↔ Cond_641_0_test_LE(>(x1, 0), x0, x1, x1)¹

(157) Complex Obligation (AND)

(158) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

The ITRS R consists of the following rules:
97_0_test_Load(x0) → 356_0_test_LE(x0, x0, x0)
356_0_test_LE(x0, x1, x1) → Cond_356_0_test_LE(x1 > 0, x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1) → 356_0_test_LE(x0, x1 + -1, x1 + -1)
356_0_test_LE(x0, 0, 0) → 389_0_test_LE(x0, x0, x0)
389_0_test_LE(x0, x1, x1) → Cond_389_0_test_LE(x1 > 0, x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1) → 389_0_test_LE(x0, x1 + -1, x1 + -1)
389_0_test_LE(x0, 0, 0) → 416_0_test_LE(x0, x0, x0)
416_0_test_LE(x0, x1, x1) → Cond_416_0_test_LE(x1 > 0, x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1) → 416_0_test_LE(x0, x1 + -1, x1 + -1)
416_0_test_LE(x0, 0, 0) → 456_0_test_LE(x0, x0, x0)
456_0_test_LE(x0, x1, x1) → Cond_456_0_test_LE(x1 > 0, x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1) → 456_0_test_LE(x0, x1 + -1, x1 + -1)
456_0_test_LE(x0, 0, 0) → 496_0_test_LE(x0, x0, x0)
496_0_test_LE(x0, x1, x1) → Cond_496_0_test_LE(x1 > 0, x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1) → 496_0_test_LE(x0, x1 + -1, x1 + -1)
496_0_test_LE(x0, 0, 0) → 528_0_test_LE(x0, x0, x0)
528_0_test_LE(x0, x1, x1) → Cond_528_0_test_LE(x1 > 0, x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1) → 528_0_test_LE(x0, x1 + -1, x1 + -1)
528_0_test_LE(x0, 0, 0) → 564_0_test_LE(x0, x0, x0)
564_0_test_LE(x0, x1, x1) → Cond_564_0_test_LE(x1 > 0, x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1) → 564_0_test_LE(x0, x1 + -1, x1 + -1)
564_0_test_LE(x0, 0, 0) → 602_0_test_LE(x0, x0, x0)
602_0_test_LE(x0, x1, x1) → Cond_602_0_test_LE(x1 > 0, x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1) → 602_0_test_LE(x0, x1 + -1, x1 + -1)
602_0_test_LE(x0, 0, 0) → 641_0_test_LE(x0, x0, x0)
641_0_test_LE(x0, x1, x1) → Cond_641_0_test_LE(x1 > 0, x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1) → 641_0_test_LE(x0, x1 + -1, x1 + -1)
641_0_test_LE(x0, 0, 0) → 680_0_test_LE(x0, x0, x0)
680_0_test_LE(x0, x1, x1) → Cond_680_0_test_LE(x1 > 0, x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1) → 680_0_test_LE(x0, x1 + -1, x1 + -1)
680_0_test_LE(x0, 0, 0) → 715_0_test_LE(x0, x0, x0)
715_0_test_LE(x0, x1, x1) → Cond_715_0_test_LE(x1 > 0, x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1) → 715_0_test_LE(x0, x1 + -1, x1 + -1)
715_0_test_LE(x0, 0, 0) → 746_0_test_LE(x0)
746_0_test_LE(0) → 751_0_test_Return
746_0_test_LE(x0) → Cond_746_0_test_LE(x0 > 0, x0)
Cond_746_0_test_LE(TRUE, x0) → 746_0_test_LE(x0 + -1)

The integer pair graph contains the following rules and edges:
(2): 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(x1[2] > 0, 751_0_test_Return, x0[2], x1[2])
(1): COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])
(0): 90_0_MAIN_GE(x0[0], x1[0]) → COND_90_0_MAIN_GE(x1[0] < 100, x0[0], x1[0])

(0) -> (1), if (x1[0] < 100 ∧x0[0] →^* x0[1]∧x1[0] →^* x1[1])

(1) -> (2), if (97_0_test_Load(x1[1]) →^* 751_0_test_Return∧x0[1] →^* x0[2]∧x1[1] →^* x1[2])

The set Q consists of the following terms:
97_0_test_Load(x0)
356_0_test_LE(x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1)
389_0_test_LE(x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1)
416_0_test_LE(x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1)
456_0_test_LE(x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1)
496_0_test_LE(x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1)
528_0_test_LE(x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1)
564_0_test_LE(x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1)
602_0_test_LE(x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1)
641_0_test_LE(x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1)
680_0_test_LE(x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1)
715_0_test_LE(x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1)
746_0_test_LE(x0)
Cond_746_0_test_LE(TRUE, x0)

(159) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 3 less nodes.

(160) TRUE

(161) Obligation:

IDP problem:
The following function symbols are pre-defined:

!=	~	Neq: (Integer, Integer) -> Boolean
*	~	Mul: (Integer, Integer) -> Integer
>=	~	Ge: (Integer, Integer) -> Boolean
-1	~	UnaryMinus: (Integer) -> Integer
|	~	Bwor: (Integer, Integer) -> Integer
/	~	Div: (Integer, Integer) -> Integer
=	~	Eq: (Integer, Integer) -> Boolean
	~	Bwxor: (Integer, Integer) -> Integer
||	~	Lor: (Boolean, Boolean) -> Boolean
!	~	Lnot: (Boolean) -> Boolean
<	~	Lt: (Integer, Integer) -> Boolean
-	~	Sub: (Integer, Integer) -> Integer
<=	~	Le: (Integer, Integer) -> Boolean
>	~	Gt: (Integer, Integer) -> Boolean
~	~	Bwnot: (Integer) -> Integer
%	~	Mod: (Integer, Integer) -> Integer
&	~	Bwand: (Integer, Integer) -> Integer
+	~	Add: (Integer, Integer) -> Integer
&&	~	Land: (Boolean, Boolean) -> Boolean

The following domains are used:

Integer

The ITRS R consists of the following rules:
97_0_test_Load(x0) → 356_0_test_LE(x0, x0, x0)
356_0_test_LE(x0, x1, x1) → Cond_356_0_test_LE(x1 > 0, x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1) → 356_0_test_LE(x0, x1 + -1, x1 + -1)
356_0_test_LE(x0, 0, 0) → 389_0_test_LE(x0, x0, x0)
389_0_test_LE(x0, x1, x1) → Cond_389_0_test_LE(x1 > 0, x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1) → 389_0_test_LE(x0, x1 + -1, x1 + -1)
389_0_test_LE(x0, 0, 0) → 416_0_test_LE(x0, x0, x0)
416_0_test_LE(x0, x1, x1) → Cond_416_0_test_LE(x1 > 0, x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1) → 416_0_test_LE(x0, x1 + -1, x1 + -1)
416_0_test_LE(x0, 0, 0) → 456_0_test_LE(x0, x0, x0)
456_0_test_LE(x0, x1, x1) → Cond_456_0_test_LE(x1 > 0, x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1) → 456_0_test_LE(x0, x1 + -1, x1 + -1)
456_0_test_LE(x0, 0, 0) → 496_0_test_LE(x0, x0, x0)
496_0_test_LE(x0, x1, x1) → Cond_496_0_test_LE(x1 > 0, x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1) → 496_0_test_LE(x0, x1 + -1, x1 + -1)
496_0_test_LE(x0, 0, 0) → 528_0_test_LE(x0, x0, x0)
528_0_test_LE(x0, x1, x1) → Cond_528_0_test_LE(x1 > 0, x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1) → 528_0_test_LE(x0, x1 + -1, x1 + -1)
528_0_test_LE(x0, 0, 0) → 564_0_test_LE(x0, x0, x0)
564_0_test_LE(x0, x1, x1) → Cond_564_0_test_LE(x1 > 0, x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1) → 564_0_test_LE(x0, x1 + -1, x1 + -1)
564_0_test_LE(x0, 0, 0) → 602_0_test_LE(x0, x0, x0)
602_0_test_LE(x0, x1, x1) → Cond_602_0_test_LE(x1 > 0, x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1) → 602_0_test_LE(x0, x1 + -1, x1 + -1)
602_0_test_LE(x0, 0, 0) → 641_0_test_LE(x0, x0, x0)
641_0_test_LE(x0, x1, x1) → Cond_641_0_test_LE(x1 > 0, x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1) → 641_0_test_LE(x0, x1 + -1, x1 + -1)
641_0_test_LE(x0, 0, 0) → 680_0_test_LE(x0, x0, x0)
680_0_test_LE(x0, x1, x1) → Cond_680_0_test_LE(x1 > 0, x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1) → 680_0_test_LE(x0, x1 + -1, x1 + -1)
680_0_test_LE(x0, 0, 0) → 715_0_test_LE(x0, x0, x0)
715_0_test_LE(x0, x1, x1) → Cond_715_0_test_LE(x1 > 0, x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1) → 715_0_test_LE(x0, x1 + -1, x1 + -1)
715_0_test_LE(x0, 0, 0) → 746_0_test_LE(x0)
746_0_test_LE(0) → 751_0_test_Return
746_0_test_LE(x0) → Cond_746_0_test_LE(x0 > 0, x0)
Cond_746_0_test_LE(TRUE, x0) → 746_0_test_LE(x0 + -1)

The integer pair graph contains the following rules and edges:
(3): COND_97_1_MAIN_INVOKEMETHOD(TRUE, 751_0_test_Return, x0[3], x1[3]) → 90_0_MAIN_GE(x0[3], x1[3] + 1)
(2): 97_1_MAIN_INVOKEMETHOD(751_0_test_Return, x0[2], x1[2]) → COND_97_1_MAIN_INVOKEMETHOD(x1[2] > 0, 751_0_test_Return, x0[2], x1[2])
(1): COND_90_0_MAIN_GE(TRUE, x0[1], x1[1]) → 97_1_MAIN_INVOKEMETHOD(97_0_test_Load(x1[1]), x0[1], x1[1])

(1) -> (2), if (97_0_test_Load(x1[1]) →^* 751_0_test_Return∧x0[1] →^* x0[2]∧x1[1] →^* x1[2])

(2) -> (3), if (x1[2] > 0 ∧x0[2] →^* x0[3]∧x1[2] →^* x1[3])

The set Q consists of the following terms:
97_0_test_Load(x0)
356_0_test_LE(x0, x1, x1)
Cond_356_0_test_LE(TRUE, x0, x1, x1)
389_0_test_LE(x0, x1, x1)
Cond_389_0_test_LE(TRUE, x0, x1, x1)
416_0_test_LE(x0, x1, x1)
Cond_416_0_test_LE(TRUE, x0, x1, x1)
456_0_test_LE(x0, x1, x1)
Cond_456_0_test_LE(TRUE, x0, x1, x1)
496_0_test_LE(x0, x1, x1)
Cond_496_0_test_LE(TRUE, x0, x1, x1)
528_0_test_LE(x0, x1, x1)
Cond_528_0_test_LE(TRUE, x0, x1, x1)
564_0_test_LE(x0, x1, x1)
Cond_564_0_test_LE(TRUE, x0, x1, x1)
602_0_test_LE(x0, x1, x1)
Cond_602_0_test_LE(TRUE, x0, x1, x1)
641_0_test_LE(x0, x1, x1)
Cond_641_0_test_LE(TRUE, x0, x1, x1)
680_0_test_LE(x0, x1, x1)
Cond_680_0_test_LE(TRUE, x0, x1, x1)
715_0_test_LE(x0, x1, x1)
Cond_715_0_test_LE(TRUE, x0, x1, x1)
746_0_test_LE(x0)
Cond_746_0_test_LE(TRUE, x0)

(162) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 3 less nodes.

(163) TRUE